/* eslint-disable @typescript-eslint/ban-ts-comment */
// @ts-nocheck
/**
 * CodeToSchemaTransformer - JSX代码转换为低代码Schema
 *
 * 【this前缀添加的边缘情况记录】
 * 已处理：
 * - ✅ 属性访问：obj.text (前面有点，跳过)
 * - ✅ 对象属性名：{ text: 'value' } (冒号前，跳过)
 * - ✅ 重复前缀：this.text (已有前缀，跳过)
 *
 * 待处理边缘情况：
 * - 🔄 函数参数：render: (text) => text (最关键，需检查currentFunctionParams)
 * - ⚠️ 数组/对象解构：const [text] = items, const { text } = data
 * - ⚠️ 嵌套作用域：内层函数参数覆盖外层参数
 * - ⚠️ 复杂参数：默认参数、解构参数、剩余参数
 * - ⚠️ 模板字符串：`Hello ${text}!`
 * - ⚠️ 计算属性名：{ [text]: 'value' } vs { normal: text }
 * - ⚠️ 三元/逻辑运算：text ? text.length : 0
 *
 * 核心检查逻辑：shouldAddThisPrefix(text, param, offset)
 * 1. 前字符检查：text.charAt(offset-1) === '.'
 * 2. 对象属性检查：/[{,]\s*$/.test(beforeContext) && /^\s*:/.test(afterContext)
 * 3. 函数参数检查：this.currentFunctionParams.includes(param)
 */

import { parse } from '@babel/parser';
import traverse from '@babel/traverse';
import generate from '@babel/generator';
import * as t from '@babel/types';
import { IPublicTypeNodeSchema, IPublicTypeRootSchema } from '@alilc/lowcode-types';
import { ParseError, TransformError } from '../types';
import { classToStyle } from './classToStyle';
import { isJSExpression } from '@alilc/lowcode-utils';
import * as fs from 'fs';
import * as path from 'path';

// 日志收集器类
class LoggerCollector {
  private static instance: LoggerCollector;
  private logs: string[] = [];
  private isEnabled: boolean = false;
  private logFilePath: string;
  private isWriting: boolean = false;
  private writeTimer: NodeJS.Timeout | null = null;
  private batchSize: number = 100; // 批量写入大小
  private writeDelay: number = 1000; // 延迟写入时间(ms)

  private constructor() {
    // 设置日志文件路径到项目运行目录下
    this.logFilePath = path.join(process.cwd(), 'code-to-schema-debug.log');
    // 默认启用日志收集（可根据需要修改）
    this.isEnabled = false; // 改为默认关闭，避免性能影响
  }

  static getInstance(): LoggerCollector {
    if (!LoggerCollector.instance) {
      LoggerCollector.instance = new LoggerCollector();
    }
    return LoggerCollector.instance;
  }

  // 设置日志开关
  setEnabled(enabled: boolean): void {
    if (this.isEnabled === enabled) return;

    this.isEnabled = enabled;
    if (enabled) {
      this.clearLogs(); // 启用时清空之前的日志
    } else {
      // 禁用时立即写入剩余日志
      this.flushLogs();
    }
  }

  // 检查是否启用
  isLoggerEnabled(): boolean {
    return this.isEnabled;
  }

  // 添加日志
  log(...args: any[]): void {
    if (!this.isEnabled) {
      return;
    }

    const timestamp = new Date().toISOString();
    const message = args
      .map((arg) => {
        if (typeof arg === 'object') {
          try {
            return JSON.stringify(arg, null, 2);
          } catch (e) {
            return String(arg);
          }
        }
        return String(arg);
      })
      .join(' ');

    const logEntry = `[${timestamp}] ${message}`;
    this.logs.push(logEntry);

    // 批量写入策略：
    // 1. 达到批次大小时立即写入
    // 2. 或者延迟写入（防抖）
    if (this.logs.length >= this.batchSize) {
      this.flushLogs();
    } else {
      this.scheduleWrite();
    }
  }

  // 安排延迟写入（防抖）
  private scheduleWrite(): void {
    if (this.writeTimer) {
      clearTimeout(this.writeTimer);
    }

    this.writeTimer = setTimeout(() => {
      this.flushLogs();
    }, this.writeDelay);
  }

  // 立即写入所有日志到文件
  flushLogs(): void {
    if (this.isWriting || this.logs.length === 0) {
      return;
    }

    this.isWriting = true;

    try {
      // 使用异步写入避免阻塞
      setImmediate(() => {
        try {
          const content = this.logs.join('\n') + '\n';
          fs.writeFileSync(this.logFilePath, content, 'utf8');
          this.logs = []; // 清空已写入的日志
        } catch (error) {
          console.warn('无法写入日志文件:', error);
        } finally {
          this.isWriting = false;
        }
      });
    } catch (error) {
      console.warn('安排日志写入失败:', error);
      this.isWriting = false;
    }
  }

  // 清空日志
  clearLogs(): void {
    // 先写入现有日志
    this.flushLogs();

    // 等待写入完成后删除文件
    setTimeout(() => {
      if (fs.existsSync(this.logFilePath)) {
        try {
          fs.unlinkSync(this.logFilePath);
        } catch (error) {
          console.warn('无法删除日志文件:', error);
        }
      }
    }, 100);
  }

  // 获取所有日志
  getLogs(): string[] {
    return [...this.logs];
  }

  // 获取日志统计信息
  getStats(): { totalLogs: number; isEnabled: boolean; filePath: string } {
    return {
      totalLogs: this.logs.length,
      isEnabled: this.isEnabled,
      filePath: this.logFilePath,
    };
  }
}

// 创建 logger 实例
const loggerCollector = LoggerCollector.getInstance();

// 导出 logger 函数和控制器
const logger = function (...args: any[]) {
  loggerCollector.log(...args);
};

// 导出日志控制器
export const loggerControl = {
  setEnabled: (enabled: boolean) => loggerCollector.setEnabled(enabled),
  isEnabled: () => loggerCollector.isLoggerEnabled(),
  clearLogs: () => loggerCollector.clearLogs(),
  getLogs: () => loggerCollector.getLogs(),
  getStats: () => loggerCollector.getStats(),
  flushLogs: () => loggerCollector.flushLogs(),
};

export class CodeToSchemaTransformer {
  private currentLoopArgs: string[] = [];
  private allLoopArgs: string[] = [];
  private currentSlotParams: string[] = [];
  // 新增：用于管理数组解构变量的映射关系
  private destructuredVarMappings: Map<string, string> = new Map(); // key: 解构变量名, value: 原始数组变量[index]
  private currentDestructuredVars: string[] = []; // 当前作用域中的解构变量
  private allDestructuredVars: string[] = []; // 所有解构变量（包括嵌套作用域）
  private componentState: Record<string, any> = {};
  private componentDefaultProps: Record<string, any> = {};
  // 新增：用于收集用到的组件名
  private usedComponentNames: Set<string> = new Set();
  // 新增：用于跟踪当前函数的参数，避免错误添加this前缀
  private currentFunctionParams: string[] = [];
  // 新增：渲染组件方法白名单，这些方法调用不会被包装成Text组件
  private renderComponentWhitelist: Set<string> = new Set([
    'renderComponent',
    'render',
    'createElement',
    'cloneElement',
  ]);

  constructor(options?: { renderComponentWhitelist?: string[] }) {
    // 如果传入了自定义白名单，则合并到默认白名单中
    if (options?.renderComponentWhitelist) {
      options.renderComponentWhitelist.forEach((method) => {
        this.renderComponentWhitelist.add(method);
      });
    }
  }

  // 添加方法到渲染组件白名单
  addToRenderComponentWhitelist(methods: string | string[]): void {
    const methodArray = Array.isArray(methods) ? methods : [methods];
    methodArray.forEach((method) => {
      this.renderComponentWhitelist.add(method);
      logger(`【addToRenderComponentWhitelist】添加方法到白名单: ${method}`);
    });
  }

  // 获取当前白名单
  getRenderComponentWhitelist(): string[] {
    return Array.from(this.renderComponentWhitelist);
  }

  // 安全检查：是否应该为参数添加this前缀
  private shouldAddThisPrefix(text: string, param: string, offset: number): boolean {
    // 1. 检查前一个字符是否是点 - 核心规则（但要排除展开运算符 ...）
    const beforeChar = text.charAt(offset - 1);
    if (beforeChar === '.') {
      // 检查是否是展开运算符 ...
      const before3Chars = text.substring(Math.max(0, offset - 3), offset);
      if (before3Chars === '...') {
        // 是展开运算符，允许添加 this 前缀
        logger(`【shouldAddThisPrefix】${param} 前面是展开运算符，允许添加this前缀`);
      } else {
        // 是普通的点号，跳过
        logger(`【shouldAddThisPrefix】${param} 前面有点，跳过添加this前缀`);
        return false;
      }
    }

    // 2. 检查是否在对象字面量的属性名位置
    // 例如：{ text: '未知' } 中的 text
    const beforeContext = text.substring(Math.max(0, offset - 10), offset);
    if (/[{,]\s*$/.test(beforeContext)) {
      const afterContext = text.substring(offset + param.length, offset + param.length + 5);
      if (/^\s*:/.test(afterContext)) {
        logger(`【shouldAddThisPrefix】${param} 是对象属性名，跳过添加this前缀`);
        return false;
      }
    }

    // 3. 检查是否是函数参数
    if (this.currentFunctionParams.includes(param)) {
      logger(`【shouldAddThisPrefix】${param} 是函数参数，跳过添加this前缀`);
      return false;
    }

    // 4. 检查是否已经有this前缀
    const beforeThis = text.substring(Math.max(0, offset - 5), offset);
    if (beforeThis.endsWith('this.')) {
      logger(`【shouldAddThisPrefix】${param} 已经有this前缀，跳过`);
      return false;
    }

    return true;
  }

  // 判断是否应该转换 className
  private shouldTransformClassName(className: string): boolean {
    if (!className || typeof className !== 'string') {
      return false;
    }

    // 检查是否包含特殊的索引映射格式，如 [0:b] [1:a] [2:c]
    const hasIndexMapping = /\[\d+:[^\]]+\]/.test(className);
    if (hasIndexMapping) {
      return false;
    }

    // 检查是否包含过多的特殊字符，可能是编码数据
    const specialCharCount = (className.match(/[\[\]:]/g) || []).length;
    const totalLength = className.length;
    if (specialCharCount > totalLength * 0.3) {
      return false;
    }

    return true;
  }

  // 检查 style 对象是否包含 JSExpression
  private hasJSExpressionInStyle(style: any): boolean {
    if (!style || typeof style !== 'object') {
      return false;
    }

    // 递归检查对象的所有属性
    for (const key in style) {
      const value = style[key];
      if (value && typeof value === 'object') {
        // 检查是否是 JSExpression 类型
        if (value.type === 'JSExpression') {
          logger(`【hasJSExpressionInStyle】发现 JSExpression 在属性 ${key}:`, value);
          return true;
        }
        // 递归检查嵌套对象
        if (this.hasJSExpressionInStyle(value)) {
          return true;
        }
      }
    }

    return false;
  }

  // 解析 CSS 样式字符串为对象
  private parseStyleString(styleString: string): Record<string, string> {
    const styleObject: Record<string, string> = {};

    if (!styleString || typeof styleString !== 'string') {
      return styleObject;
    }

    try {
      // 移除末尾的分号并按分号分割
      const declarations = styleString.replace(/;$/, '').split(';');

      declarations.forEach((declaration) => {
        const colonIndex = declaration.indexOf(':');
        if (colonIndex > 0) {
          const property = declaration.substring(0, colonIndex).trim();
          const value = declaration.substring(colonIndex + 1).trim();
          if (property && value) {
            // 将 CSS 属性名转换为 camelCase（React 样式对象格式）
            const camelCaseProperty = this.cssPropToCamelCase(property);
            styleObject[camelCaseProperty] = value;
          }
        }
      });

      logger(`【parseStyleString】解析样式字符串: "${styleString}" -> `, styleObject);
      return styleObject;
    } catch (error) {
      console.warn('【parseStyleString】样式解析失败，返回空对象:', error);
      return {};
    }
  }

  // 将 CSS 属性名转换为 camelCase
  private cssPropToCamelCase(cssProperty: string): string {
    return cssProperty.replace(/-([a-z])/g, (match, letter) => letter.toUpperCase());
  }

  // 合并字符串样式和对象样式
  private mergeStyleWithString(
    styleString: string,
    styleObject: Record<string, string>,
  ): Record<string, string> {
    const parsedStyle = this.parseStyleString(styleString);
    // 合并样式对象（styleObject 优先级更高）
    return { ...parsedStyle, ...styleObject };
  }

  async transform(
    code: string,
    options?: {
      reactNodeProps?: string[];
    },
  ): Promise<{
    methods: Array<{ name: string; desc: string; code: string }>;
    properties: Array<{ name: string; desc: string; code: string }>;
    schema: IPublicTypeNodeSchema;
    usedComponentNames: string[];
    defaultProps?: Record<string, any>;
  }> {
    // 每次transform前清空组件名集合和状态
    this.usedComponentNames.clear();
    this.componentDefaultProps = {};

    // 如果传入了 ReactNode 属性列表，添加到白名单
    if (options?.reactNodeProps && options.reactNodeProps.length > 0) {
      logger(`【transform】添加ReactNode属性到白名单:`, options.reactNodeProps);
      this.addToRenderComponentWhitelist(options.reactNodeProps);
    }

    let classDepth = 0; // 新增：用于判断class嵌套层级
    let inRootClass = false; // 新增：标记当前是否在根 class
    try {
      // 1. 解析 JSX 代码为 AST
      const ast = parse(code, {
        sourceType: 'module',
        plugins: ['jsx', 'typescript'],
      });

      // logger('fuck ast: ', ast);

      // 2. 遍历 AST 构建 schema 和解析方法
      let rootSchema: IPublicTypeNodeSchema | null = null;
      let isFindClassRenderRoot = false;
      const methods: Array<{ name: string; desc: string; code: string }> = [];
      const properties: Array<{ name: string; desc: string; code: string }> = [];

      traverse(ast, {
        ClassDeclaration: {
          enter(path) {
            classDepth++;
            if (classDepth === 1) {
              inRootClass = true; // 进入根 class
              // 只检查根部 class
              const hasConstructor = path.node.body.body.some(
                (member) => t.isClassMethod(member) && member.kind === 'constructor',
              );
              if (hasConstructor) {
                throw new Error('根部 React 组件 class 不允许使用 constructor');
              }
            }
          },
          exit(path) {
            if (classDepth === 1) {
              inRootClass = false; // 离开根 class
            }
            classDepth--;
          },
        },
        ClassProperty: (path) => {
          // 检查是否是类的直接属性（而不是嵌套在其他方法内部的属性）
          if (!inRootClass) {
            return; // 只收集根 class 的属性
          }
          if (!t.isClassBody(path.parent)) {
            return; // 跳过嵌套属性
          }

          if (t.isIdentifier(path.node.key)) {
            const propertyName = path.node.key.name;

            // 处理 state
            if (propertyName === 'state') {
              this.processClassProperty(path.node);
              return;
            }

            // 处理 defaultProps
            if (propertyName === 'defaultProps') {
              this.processDefaultPropsProperty(path.node);
              return;
            }

            // 处理其他类属性成员（如 statusMap, universityTypeMap 等）
            // 将它们转换为 JSExpression 并放在 properties 中
            if (path.node.value && !t.isArrowFunctionExpression(path.node.value)) {
              // 检查是否已经收集过同名属性，避免重复收集
              const existingProperty = properties.find((p) => p.name === propertyName);
              if (existingProperty) {
                logger(`跳过重复属性: ${propertyName}`);
                return;
              }

              // 获取属性的注释
              const comments = path.node.leadingComments || [];
              let desc = comments
                .map((comment) => comment.value.trim())
                .map((comment) => comment.replace(/^\*+/, '').trim()) // 移除开头的星号
                .join('\n');

              if (desc.startsWith('* ')) {
                desc = desc.substring(2);
              }

              // 如果没有注释，使用属性名作为描述
              if (!desc) {
                desc = `类属性: ${propertyName}`;
              }

              try {
                // 生成属性值的代码
                const propertyValueCode = generate(path.node.value).code;

                // 将属性转换为JSExpression，直接使用属性值
                const jsExpressionCode = propertyValueCode;

                // 添加到属性列表
                properties.push({
                  name: propertyName,
                  desc,
                  code: jsExpressionCode.trim(),
                });

                logger(`【ClassProperty】将类属性 ${propertyName} 转换为JSExpression`);
              } catch (error) {
                logger(`【ClassProperty】处理类属性 ${propertyName} 失败:`, error);
              }
              return;
            }

            // 处理箭头函数属性
            if (t.isArrowFunctionExpression(path.node.value)) {
              // 检查是否已经收集过同名方法，避免重复收集
              const existingMethod = methods.find((m) => m.name === propertyName);
              if (existingMethod) {
                logger(`跳过重复属性方法: ${propertyName}`);
                return;
              }

              // 获取属性的注释
              const comments = path.node.leadingComments || [];
              let desc = comments
                .map((comment) => comment.value.trim())
                .map((comment) => comment.replace(/^\*+/, '').trim()) // 移除开头的星号
                .join('\n');

              if (desc.startsWith('* ')) {
                desc = desc.substring(2);
              }

              // 获取箭头函数的参数
              const params = path.node.value.params
                .map((param) => {
                  if (t.isIdentifier(param)) {
                    return param.name;
                  } else if (t.isObjectPattern(param)) {
                    // 处理解构参数
                    return `{${param.properties
                      .map((prop) => {
                        if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
                          return prop.key.name;
                        }
                        return '';
                      })
                      .filter(Boolean)
                      .join(', ')}}`;
                  } else if (t.isAssignmentPattern(param)) {
                    // 处理带默认值的参数
                    const paramName = t.isIdentifier(param.left) ? param.left.name : '';
                    const defaultValue = generate(param.right).code;
                    return paramName ? `${paramName} = ${defaultValue}` : '';
                  }
                  return '';
                })
                .filter(Boolean);

              // 获取函数体代码
              let bodyCode = '';
              if (t.isBlockStatement(path.node.value.body)) {
                bodyCode = generate(path.node.value.body).code;
                // 移除多余的大括号
                bodyCode = bodyCode.replace(/^{|}$/g, '').trim();
              } else {
                // 如果是表达式体，需要添加 return
                bodyCode = `return ${generate(path.node.value.body).code};`;
              }

              // 构建完整的函数代码
              const isAsync = path.node.value.async;
              const functionCode = isAsync
                ? `async function ${propertyName}(${params.join(', ')}) {\n${bodyCode}\n}`
                : `function ${propertyName}(${params.join(', ')}) {\n${bodyCode}\n}`;

              // 添加到方法列表
              methods.push({
                name: propertyName,
                desc,
                code: functionCode.trim(),
              });
            }
          }
        },
        CallExpression: (path) => {
          if (t.isIdentifier(path.node.callee) && path.node.callee.name === 'useState') {
            const parent = path.findParent((p) => t.isVariableDeclarator(p));
            if (parent && t.isVariableDeclarator(parent.node)) {
              if (t.isArrayPattern(parent.node.id)) {
                const stateName = parent.node.id.elements[0]?.name;
                if (stateName) {
                  const { code: initValue } = generate(parent.node.init);

                  // 尝试解析原始值
                  try {
                    // 首先尝试直接解析JSON
                    const parsedValue = JSON.parse(initValue.trim());
                    this.componentState[stateName] = parsedValue;
                  } catch {
                    // 如果直接解析失败，尝试将字符串转换为可执行的JavaScript表达式
                    try {
                      // 对于形如 [{ ... }] 或 { ... } 的字符串，尝试将其转换为有效的JavaScript表达式
                      // 注意：这里使用eval是安全的，因为我们只处理来自代码的静态值
                      const jsExpression = initValue.trim();
                      // 使用Function构造函数而不是直接eval，更安全
                      const evalFunc = new Function('return ' + jsExpression);
                      const evalValue = evalFunc();

                      // 确保结果是一个有效的值
                      if (evalValue !== undefined) {
                        this.componentState[stateName] = evalValue;
                      } else {
                        // 如果解析失败，保持原始字符串值
                        this.componentState[stateName] = initValue.trim();
                      }
                    } catch {
                      // 如果所有解析方法都失败，保持原始字符串值
                      this.componentState[stateName] = initValue.trim();
                    }
                  }
                }
              }
            }
          }
        },
        ClassMethod: (path) => {
          // 检查是否是类的直接方法（而不是嵌套在其他方法内部的函数）
          if (!inRootClass) {
            return; // 只收集根 class 的方法
          }
          if (!t.isClassBody(path.parent)) {
            return; // 跳过嵌套函数
          }

          // 获取方法名
          const methodName = path.node.key.name;

          // 处理 render 方法
          if (methodName === 'render') {
            const returnStatement = path.node.body.body.find(
              (node) => node.type === 'ReturnStatement',
            );
            if (returnStatement && returnStatement.argument) {
              rootSchema = this.transformJSXElement(returnStatement.argument);
              logger('rootSchema Name 1: ', rootSchema.componentName);
              isFindClassRenderRoot = true;
            }
            return; // 直接返回，不处理 render 方法
          }

          // 检查是否已经收集过同名方法，避免重复收集
          const existingMethod = methods.find((m) => m.name === methodName);
          if (existingMethod) {
            logger(`跳过重复方法: ${methodName}`);
            return;
          }

          // 获取方法的注释
          const comments = path.node.leadingComments || [];
          let desc = comments
            .map((comment) => comment.value.trim())
            .map((comment) => comment.replace(/^\*+/, '').trim()) // 移除开头的星号
            .join('\n');

          if (desc.startsWith('* ')) {
            desc = desc.substring(2);
          }

          // 获取方法的参数
          const params = path.node.params
            .map((param) => {
              if (t.isIdentifier(param)) {
                return param.name;
              } else if (t.isObjectPattern(param)) {
                // 处理解构参数
                return `{${param.properties
                  .map((prop) => {
                    if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
                      return prop.key.name;
                    }
                    return '';
                  })
                  .filter(Boolean)
                  .join(', ')}}`;
              } else if (t.isAssignmentPattern(param)) {
                // 处理带默认值的参数
                const paramName = t.isIdentifier(param.left) ? param.left.name : '';
                const defaultValue = generate(param.right).code;
                return paramName ? `${paramName} = ${defaultValue}` : '';
              }
              return '';
            })
            .filter(Boolean);

          // 获取方法代码并转换为独立函数
          const methodCode = generate(path.node.body).code;
          const isAsync = path.node.async;
          // 移除多余的大括号
          const cleanCode = methodCode.replace(/^{|}$/g, '').trim();
          const functionCode = isAsync
            ? `async function ${methodName}(${params.join(', ')}) {\n${cleanCode}\n}`
            : `function ${methodName}(${params.join(', ')}) {\n${cleanCode}\n}`;

          // 添加到方法列表
          methods.push({
            name: methodName,
            desc,
            code: functionCode.trim(),
          });

          // 检查是否是根组件
          const returnStatement = path.node.body.body.find(
            (node) => node.type === 'ReturnStatement',
          );
          if (returnStatement && returnStatement.argument) {
            rootSchema = this.transformJSXElement(returnStatement.argument);
            logger('rootSchema Name 2: ', rootSchema.componentName);
          }
        },
        FunctionDeclaration: (path) => {
          // 检查是否是顶级函数声明（而不是嵌套在类方法或其他函数内部）
          const isTopLevel =
            t.isProgram(path.parent) ||
            (t.isExportDefaultDeclaration(path.parent) && t.isProgram(path.parent.parent)) ||
            (t.isExportNamedDeclaration(path.parent) && t.isProgram(path.parent.parent));

          if (!isTopLevel) {
            return; // 跳过嵌套函数声明
          }

          // 获取函数名
          const functionName = path.node.id?.name;
          if (!functionName) return;

          // 获取函数源代码，保留内部注释
          const { code: functionCode } = generate(path.node, {
            retainLines: false,
            retainFunctionParens: true,
            comments: true, // 保留注释
            compact: false,
            concise: false,
            jsescOption: {
              minimal: true,
            },
          });

          // 获取函数的注释
          const comments = path.node.leadingComments || [];
          let desc = comments
            .map((comment) => comment.value.trim())
            .map((comment) => comment.replace(/^\*+/, '').trim()) // 移除开头的星号
            .join('\n');

          if (desc.startsWith('* ')) {
            desc = desc.substring(2);
          }

          // 添加到方法列表
          methods.push({
            name: functionName,
            desc,
            code: functionCode.trim(),
          });

          // 检查是否是根组件
          const returnStatement = path.node.body.body.find(
            (node) => node.type === 'ReturnStatement',
          );
          if (returnStatement && returnStatement.argument) {
            rootSchema = this.transformJSXElement(returnStatement.argument);
            logger('rootSchema Name 2: ', rootSchema.componentName);
          }
        },
        ArrowFunctionExpression: (path) => {
          // 只处理顶级的箭头函数组件（通常是 export default 或变量声明中的）
          const isTopLevelComponent =
            t.isVariableDeclarator(path.parent) &&
            t.isVariableDeclaration(path.parent.parent) &&
            (t.isProgram(path.parent.parent.parent) ||
              t.isExportDefaultDeclaration(path.parent.parent.parent) ||
              t.isExportNamedDeclaration(path.parent.parent.parent));

          if (!isTopLevelComponent) {
            return; // 跳过嵌套的箭头函数
          }

          if (t.isBlockStatement(path.node.body)) {
            const returnStatement = path.node.body.body.find(
              (node) => node.type === 'ReturnStatement',
            );
            if (returnStatement && returnStatement.argument) {
              const nodeSchema = this.transformJSXElement(returnStatement.argument);
              if (nodeSchema?.componentName) {
                rootSchema = nodeSchema;
                logger('rootSchema Name 3: ', rootSchema.componentName, returnStatement.argument);
                isFindClassRenderRoot = true;
              }
            }
          } else if (t.isJSXElement(path.node.body)) {
            if (!isFindClassRenderRoot) {
              rootSchema = this.transformJSXElement(path.node.body);
              logger('rootSchema Name: 4', rootSchema.componentName);
            }
          }
        },
      });

      // 在保存文件前添加规范检查
      // const validationResult = validateTSXContent(code);
      // const validateErrors = validationResult.issues.filter(issue => issue.type === 'error');
      // if (validateErrors.length > 0) {
      //   const errorMessage = validateErrors.map(err => `[${err.code}] ${err.message}`).join('\n');
      //   throw new Error(`JSX规范检查失败:\n${errorMessage}`);
      // }

      if (!rootSchema) {
        throw new Error('未找到根组件');
      }

      return {
        methods,
        properties,
        schema: {
          ...rootSchema,
          ...(Object.keys(this.componentState).length > 0 ? { state: this.componentState } : {}),
        } as IPublicTypeNodeSchema & { state?: Record<string, any> },
        usedComponentNames: this.getUsedComponentNames(),
        ...(Object.keys(this.componentDefaultProps).length > 0
          ? { defaultProps: this.componentDefaultProps }
          : {}),
      };
    } catch (error) {
      console.error(error);
      if (error instanceof ParseError) {
        throw new TransformError('JSX 解析错误', error);
      }
      throw error;
    }
  }

  // 获取从this解构的变量列表
  private getDestructuredVars(code: string): string[] {
    const destructuringFromThisRegex = /(?:const|let)\s*{([^}]*)}\s*=\s*this\s*;/;
    const matches = code.match(destructuringFromThisRegex);
    if (matches) {
      logger('【transformArrowFunctionToNormalFunction】检测到从this解构的模式');
      const destructuredVars = matches[1]
        .trim()
        .split(',')
        .map((s) => s.trim());
      logger('解构的变量列表:', destructuredVars);
      return destructuredVars;
    }
    return [];
  }

  // 智能分割对象属性，考虑注释的情况
  private splitObjectProperties(content: string): string[] {
    const props: string[] = [];
    let currentProp = '';
    let braceLevel = 0;
    let inString = false;
    let stringChar = '';
    let inComment = false;
    let i = 0;

    while (i < content.length) {
      const char = content[i];
      const nextChar = content[i + 1];

      // 处理字符串
      if (!inString && !inComment && (char === '"' || char === "'" || char === '`')) {
        inString = true;
        stringChar = char;
        currentProp += char;
      } else if (inString && char === stringChar && content[i - 1] !== '\\') {
        inString = false;
        stringChar = '';
        currentProp += char;
      } else if (inString) {
        currentProp += char;
      }
      // 处理注释
      else if (!inString && char === '/' && nextChar === '/') {
        inComment = true;
        currentProp += char;
      } else if (inComment && char === '\n') {
        inComment = false;
        currentProp += char;
      } else if (inComment) {
        currentProp += char;
      }
      // 处理大括号嵌套
      else if (!inComment && char === '{') {
        braceLevel++;
        currentProp += char;
      } else if (!inComment && char === '}') {
        braceLevel--;
        currentProp += char;
      }
      // 处理逗号分割
      else if (!inComment && char === ',' && braceLevel === 0) {
        if (currentProp.trim()) {
          props.push(currentProp.trim());
        }
        currentProp = '';
      } else {
        currentProp += char;
      }

      i++;
    }

    // 添加最后一个属性
    if (currentProp.trim()) {
      props.push(currentProp.trim());
    }

    return props;
  }

  private checkDestructure(code) {
    // 使用正则表达式匹配解构模式
    const destructuringFromThisRegex = /(?:const|let)\s*{([^}]*)}\s*=\s*this\s*;/;
    const matches = code.match(destructuringFromThisRegex);
    if (matches) {
      logger('【transformArrowFunctionToNormalFunction】检测到从this解构的模式');
      logger(
        '解构的变量列表:',
        matches[1]
          .trim()
          .split(',')
          .map((s) => s.trim()),
      );
      // TODO: 这里可以添加处理解构的逻辑
      return false;
    }
    return true;
  }

  // 动态提取代码中的所有函数参数
  private extractAllFunctionParams(code: string): string[] {
    const params: string[] = [];

    // 方法1: 使用全局正则匹配，但改进匹配逻辑
    // 匹配箭头函数参数：(param1, param2) => 或 param =>
    const arrowFunctionRegex = /(?:^|[^a-zA-Z0-9_$])(?:\(([^)]*)\)|(\w+))\s*=>/g;
    let match;
    while ((match = arrowFunctionRegex.exec(code)) !== null) {
      logger('【extractAllFunctionParams】匹配到箭头函数:', match[0]);
      if (match[1]) {
        // 多参数形式：(param1, param2) =>
        let paramStr = match[1].trim();
        logger('【extractAllFunctionParams】多参数字符串:', paramStr);

        // 处理嵌套括号的情况，移除开头的额外括号
        while (paramStr.startsWith('(')) {
          paramStr = paramStr.substring(1);
        }

        if (paramStr) {
          // 处理数组解构参数，如 [key, type] 或 [a, b, c]
          if (paramStr.startsWith('[') && paramStr.endsWith(']')) {
            logger('【extractAllFunctionParams】检测到数组解构参数:', paramStr);
            const destructuredParams = paramStr
              .slice(1, -1) // 移除 [ 和 ]
              .split(',')
              .map((p) => p.trim())
              .filter((p) => p && /^\w+$/.test(p));
            logger('【extractAllFunctionParams】提取的数组解构参数:', destructuredParams);
            params.push(...destructuredParams);
          } else {
            // 普通参数处理
            const paramList = paramStr
              .split(',')
              .map((p) => p.trim())
              .filter((p) => p && /^\w+$/.test(p));
            logger('【extractAllFunctionParams】提取的多参数:', paramList);
            params.push(...paramList);
          }
        }
      } else if (match[2]) {
        // 单参数形式：param =>
        logger('【extractAllFunctionParams】单参数:', match[2]);
        params.push(match[2]);
      }
    }

    // 方法2: 专门匹配 .map 函数的参数，包括数组解构
    const mapRegex = /\.map\s*\(\s*\(([^)]+)\)/g;
    while ((match = mapRegex.exec(code)) !== null) {
      logger('【extractAllFunctionParams】匹配到map函数:', match[0]);
      const paramStr = match[1].trim();
      if (paramStr) {
        // 处理数组解构参数，如 [key, type]
        if (paramStr.startsWith('[') && paramStr.endsWith(']')) {
          logger('【extractAllFunctionParams】map函数中检测到数组解构参数:', paramStr);
          const destructuredParams = paramStr
            .slice(1, -1) // 移除 [ 和 ]
            .split(',')
            .map((p) => p.trim())
            .filter((p) => p && /^\w+$/.test(p));
          logger('【extractAllFunctionParams】map函数中提取的数组解构参数:', destructuredParams);
          params.push(...destructuredParams);
        } else {
          // 普通参数处理
          const paramList = paramStr
            .split(',')
            .map((p) => p.trim())
            .filter((p) => p && /^\w+$/.test(p));
          logger('【extractAllFunctionParams】提取的map参数:', paramList);
          params.push(...paramList);
        }
      }
    }

    // 方法3: 专门匹配 .map 函数的数组解构参数（无括号形式）
    const mapDestructuringRegex = /\.map\s*\(\s*\[([^\]]+)\]\s*=>/g;
    while ((match = mapDestructuringRegex.exec(code)) !== null) {
      logger('【extractAllFunctionParams】匹配到map函数数组解构（无括号）:', match[0]);
      const paramStr = match[1].trim();
      if (paramStr) {
        const destructuredParams = paramStr
          .split(',')
          .map((p) => p.trim())
          .filter((p) => p && /^\w+$/.test(p));
        logger('【extractAllFunctionParams】提取的map数组解构参数（无括号）:', destructuredParams);
        params.push(...destructuredParams);
      }
    }

    // 匹配普通函数参数：function(param1, param2)
    const functionRegex = /function\s*\w*\s*\(([^)]*)\)/g;
    let functionMatch;
    while ((functionMatch = functionRegex.exec(code)) !== null) {
      logger('【extractAllFunctionParams】匹配到普通函数:', functionMatch[0]);
      if (functionMatch[1]) {
        const paramStr = functionMatch[1].trim();
        logger('【extractAllFunctionParams】普通函数参数字符串:', paramStr);
        if (paramStr) {
          const paramList = paramStr
            .split(',')
            .map((p) => p.trim())
            .filter((p) => p && /^\w+$/.test(p));
          logger('【extractAllFunctionParams】提取的普通函数参数:', paramList);
          params.push(...paramList);
        }
      }
    }

    const uniqueParams = [...new Set(params)]; // 去重
    logger('【extractAllFunctionParams】最终提取的所有参数:', uniqueParams);
    return uniqueParams;
  }

  private transformJSFunctionAddThis(sourceCode: string, functionParams: string[] = []) {
    let code = sourceCode;

    // 先保护字符串字面量，避免字符串内的内容被错误替换
    const stringLiterals: string[] = [];
    let stringIndex = 0;

    // 匹配单引号、双引号和模板字符串
    code = code.replace(/('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*`)/g, (match) => {
      const placeholder = `__STRING_LITERAL_${stringIndex}__`;
      stringLiterals.push(match);
      stringIndex++;
      return placeholder;
    });

    // 检查函数体中是否包含循环变量或作用域变量
    logger('this.currentLoopArgs: ', this.currentLoopArgs);
    logger('this.currentSlotParams: ', this.currentSlotParams);
    logger('this.currentDestructuredVars: ', this.currentDestructuredVars);
    const hasLoopVars = this.currentLoopArgs.some((arg) => code.includes(arg));
    const hasSlotParams = this.currentSlotParams.some((param) => code.includes(param));
    const hasDestructuredVars = this.currentDestructuredVars.some((varName) =>
      code.includes(varName),
    );
    logger(`【transformArrowFunctionToNormalFunction】是否包含循环变量:`, hasLoopVars);
    logger(`【transformArrowFunctionToNormalFunction】是否包含作用域变量:`, hasSlotParams);
    logger(`【transformArrowFunctionToNormalFunction】是否包含解构变量:`, hasDestructuredVars);

    // 动态提取代码中的所有函数参数
    const dynamicParams = this.extractAllFunctionParams(code);
    const allFunctionParams = [...new Set([...functionParams, ...dynamicParams])];
    logger('【transformJSFunctionAddThis】传入的函数参数:', functionParams);
    logger('【transformJSFunctionAddThis】动态提取的函数参数:', dynamicParams);
    logger('【transformJSFunctionAddThis】所有函数参数:', allFunctionParams);
    logger('【transformJSFunctionAddThis】当前代码片段:', code.substring(0, 200) + '...');

    if (hasLoopVars || hasSlotParams || hasDestructuredVars) {
      // 如果包含循环变量或作用域变量，需要确保正确添加this前缀
      // 处理循环变量
      this.currentLoopArgs.forEach((arg) => {
        // 检查是否是函数参数，如果是函数参数则跳过
        if (allFunctionParams.includes(arg)) {
          logger(`【transformArrowFunctionToNormalFunction】${arg} 是函数参数，跳过添加this前缀`);
          return;
        }

        // 修改正则表达式，确保不会匹配到对象属性名
        // 使用负向前瞻，确保后面不是冒号
        const pattern = new RegExp(`\\b${arg}\\b(?!\\s*:)`, 'g');

        if (pattern.test(code)) {
          // 检查是否已经添加了this前缀
          if (code.includes(`this.${arg}`)) {
            logger(
              `【transformArrowFunctionToNormalFunction】循环变量 ${arg} 已经有this前缀，跳过`,
            );
            return;
          }
          if (!this.checkDestructure(code)) {
            return;
          }

          logger(`【transformArrowFunctionToNormalFunction】为循环变量 ${arg} 添加this前缀`);
          code = code.replace(pattern, `this.${arg}`);
        }
      });

      // 获取从this解构的变量列表
      const destructuredVars = this.getDestructuredVars(code);

      // 处理作用域变量
      this.currentSlotParams.forEach((param) => {
        // 检查是否是函数参数，如果是函数参数则跳过
        if (allFunctionParams.includes(param)) {
          logger(`【transformArrowFunctionToNormalFunction】${param} 是函数参数，跳过添加this前缀`);
          return;
        }

        // 检查是否是解构的变量，如果是则跳过
        if (destructuredVars.includes(param)) {
          logger(`【transformArrowFunctionToNormalFunction】${param} 是解构变量，跳过添加this前缀`);
          return;
        }

        // 修改正则表达式，确保不会匹配到对象属性名
        // 使用负向前瞻，确保后面不是冒号
        const pattern = new RegExp(`\\b${param}\\b(?!\\s*:)`, 'g');
        if (pattern.test(code)) {
          // 检查是否已经添加了this前缀
          if (code.includes(`this.${param}`)) {
            logger(
              `【transformArrowFunctionToNormalFunction】作用域变量 ${param} 已经有this前缀，跳过`,
            );
            return;
          }
          logger(`【transformArrowFunctionToNormalFunction】为作用域变量 ${param} 添加this前缀`);
          code = code.replace(pattern, `this.${param}`);
        }
      });

      // 处理解构变量（优先级最高，因为需要替换为数组访问形式）
      this.currentDestructuredVars.forEach((varName) => {
        // 检查是否是函数参数，如果是函数参数则跳过
        if (allFunctionParams.includes(varName)) {
          logger(`【transformJSFunctionAddThis】${varName} 是函数参数，跳过解构变量替换`);
          return;
        }

        const mapping = this.destructuredVarMappings.get(varName);
        if (mapping) {
          // 使用正则表达式替换解构变量为对应的数组访问
          const pattern = new RegExp(`\\b${varName}\\b(?!\\s*:)`, 'g');
          if (pattern.test(code)) {
            logger(`【transformJSFunctionAddThis】替换解构变量 ${varName} 为 ${mapping}`);
            code = code.replace(pattern, mapping);
          }
        }
      });

      // 处理循环变量（包括外层循环变量）
      this.allLoopArgs.forEach((param) => {
        // 检查是否是函数参数，如果是函数参数则跳过
        if (allFunctionParams.includes(param)) {
          logger(`【transformArrowFunctionToNormalFunction】${param} 是函数参数，跳过添加this前缀`);
          return;
        }

        // 检查是否是解构的变量，如果是则跳过
        if (destructuredVars.includes(param)) {
          logger(`【transformArrowFunctionToNormalFunction】${param} 是解构变量，跳过添加this前缀`);
          return;
        }

        // 修改正则表达式，确保不会匹配到对象属性名
        const pattern = new RegExp(`\\b${param}\\b(?!\\s*:)`, 'g');
        if (pattern.test(code)) {
          // 检查是否已经添加了this前缀
          if (code.includes(`this.${param}`)) {
            logger(
              `【transformArrowFunctionToNormalFunction】循环变量 ${param} 已经有this前缀，跳过`,
            );
            return;
          }
          logger(`【transformArrowFunctionToNormalFunction】为循环变量 ${param} 添加this前缀`);
          code = code.replace(pattern, `this.${param}`);
        }
      });

      // 特殊处理对象字面量中的简写属性
      // 匹配形如 { item: record, index } 中的 index
      // 使用更精确的正则表达式，避免匹配函数体和模板字符串中的 ${}
      const objectPattern = /{[^{}]*}/g;
      const matches = code.match(objectPattern);
      logger(`【transformArrowFunctionToNormalFunction】检查对象字面量，当前代码:`, code);
      logger(`【transformArrowFunctionToNormalFunction】当前作用域参数:`, this.currentSlotParams);
      if (matches) {
        logger(`【transformArrowFunctionToNormalFunction】找到对象字面量:`, matches);

        // 过滤掉包含 return 关键字的匹配（这些是函数体，不是对象字面量）
        // 同时过滤掉模板字符串中的 ${} 表达式
        const objectLiterals = matches.filter((match) => {
          // 排除函数体
          if (match.includes('return')) {
            return false;
          }
          // 排除模板字符串中的 ${} 表达式
          // 检查前面是否有 $ 符号，如果有则说明这是模板字符串的一部分
          const matchIndex = code.indexOf(match);
          if (matchIndex > 0 && code[matchIndex - 1] === '$') {
            logger(`【transformArrowFunctionToNormalFunction】跳过模板字符串表达式: ${match}`);
            return false;
          }
          return true;
        });
        logger(`【transformArrowFunctionToNormalFunction】过滤后的对象字面量:`, objectLiterals);

        objectLiterals.forEach((match) => {
          logger(`【transformArrowFunctionToNormalFunction】处理对象字面量:`, match);

          // 分割对象字面量的属性，考虑注释的情况
          const objectContent = match.slice(1, -1);
          const props = this.splitObjectProperties(objectContent);
          logger(`【transformArrowFunctionToNormalFunction】分割的属性:`, props);

          // 处理每个属性
          const processedProps = props.map((prop) => {
            logger(`【transformArrowFunctionToNormalFunction】处理属性: "${prop}"`);

            // 如果属性包含冒号，说明不是简写形式
            if (prop.includes(':')) {
              logger(
                `【transformArrowFunctionToNormalFunction】属性包含冒号，不是简写形式: "${prop}"`,
              );
              return prop;
            }

            // 检查是否是 this.变量名 的形式
            const thisPattern = /^this\.(\w+)$/;
            const thisMatch = prop.match(thisPattern);
            if (thisMatch) {
              const varName = thisMatch[1];
              logger(
                `【transformArrowFunctionToNormalFunction】发现this.变量形式: "${prop}" -> "${varName}: this.${varName}"`,
              );
              return `${varName}: this.${varName}`;
            }

            // 检查是否是作用域变量的简写形式（普通变量名）
            logger(`【transformArrowFunctionToNormalFunction】检查是否为作用域变量简写: "${prop}"`);
            logger(
              `【transformArrowFunctionToNormalFunction】当前作用域参数包含此变量?`,
              this.currentSlotParams.includes(prop),
            );
            if (this.currentSlotParams.includes(prop)) {
              logger(
                `【transformArrowFunctionToNormalFunction】发现作用域变量简写: "${prop}" -> "${prop}: this.${prop}"`,
              );
              return `${prop}: this.${prop}`;
            }

            logger(`【transformArrowFunctionToNormalFunction】属性保持不变: "${prop}"`);
            return prop;
          });

          // 重新组合对象字面量，保持原有的换行格式
          // 检查原始对象是否是多行格式
          const isMultiline = match.includes('\n');
          let newObjectLiteral;

          if (isMultiline) {
            // 多行格式：保持换行和缩进
            const indent = '  '; // 基础缩进
            const formattedProps = processedProps.map((prop) => `${indent}${prop}`).join(',\n');
            newObjectLiteral = `{\n${formattedProps}\n}`;
          } else {
            // 单行格式
            newObjectLiteral = `{ ${processedProps.join(', ')} }`;
          }

          logger(`【transformArrowFunctionToNormalFunction】处理后的对象字面量:`, newObjectLiteral);
          logger(`【transformArrowFunctionToNormalFunction】替换前代码:`, code);

          code = code.replace(match, newObjectLiteral);
          logger(`【transformArrowFunctionToNormalFunction】替换后代码:`, code);
        });
      } else {
        logger(`【transformArrowFunctionToNormalFunction】未找到对象字面量`);
      }

      // 修复可能出现的语法错误
      code = code
        .replace(/,\s*}/g, ' }') // 移除对象末尾的逗号
        .replace(/{\s*,/g, '{ ') // 移除对象开头的逗号
        .replace(/,\s*,/g, ','); // 移除重复的逗号

      logger(`【transformArrowFunctionToNormalFunction】最终处理结果:`, code);
    }

    // 恢复字符串字面量
    stringLiterals.forEach((literal, index) => {
      const placeholder = `__STRING_LITERAL_${index}__`;
      code = code.replace(placeholder, literal);
    });

    return code;
  }

  private transformJSXAttributeValue(
    value: t.JSXAttribute['value'],
    componentName?: string,
    attrName?: string,
  ): any {
    logger(
      `【transformJSXAttributeValue】开始处理属性值 - 组件:${componentName}, 属性:${attrName}`,
    );

    logger('value: ', value);
    logger('value type: ', value?.type);

    // 特别关注 suffixIcon 属性
    if (attrName === 'suffixIcon') {
      logger('🔥【SUFFIX_ICON_DEBUG】处理 suffixIcon 属性');
      logger('🔥【SUFFIX_ICON_DEBUG】value 类型:', value?.type);
      if (value && 'expression' in value) {
        logger('🔥【SUFFIX_ICON_DEBUG】expression 类型:', value.expression?.type);
      }
    }

    if (value === null) {
      logger(`【transformJSXAttributeValue】属性值为null，返回true`);
      return true;
    }

    if (t.isStringLiteral(value)) {
      logger(`【transformJSXAttributeValue】处理字符串字面量: "${value.value}"`);
      return value.value;
    }

    // 处理特殊的条件属性
    if (t.isJSXExpressionContainer(value) && t.isLogicalExpression(value.expression)) {
      logger(`【transformJSXAttributeValue】处理逻辑表达式: ${value.expression.operator}`);

      // 检查逻辑表达式的右侧是否为JSX元素
      if (t.isJSXElement(value.expression.right)) {
        logger(`【transformJSXAttributeValue】逻辑表达式中包含JSX元素，转换为JSSlot`);

        // 获取条件表达式
        const leftCode = generate(value.expression.left).code;
        let conditionValue = leftCode;

        // 处理条件表达式中的变量引用
        this.currentSlotParams.forEach((param) => {
          const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*[:=])`, 'g');
          if (paramPattern.test(conditionValue)) {
            logger(
              `【transformJSXAttributeValue】为条件表达式中的JSSlot参数 ${param} 添加this前缀`,
            );
            conditionValue = conditionValue.replace(paramPattern, `this.${param}`);
          }
        });

        this.allLoopArgs.forEach((arg) => {
          const argPattern = new RegExp(`\\b${arg}\\b(?!\\s*[:=])`, 'g');
          if (argPattern.test(conditionValue) && !conditionValue.includes(`this.${arg}`)) {
            logger(`【transformJSXAttributeValue】为条件表达式中的循环变量 ${arg} 添加this前缀`);
            conditionValue = conditionValue.replace(argPattern, `this.${arg}`);
          }
        });

        // 转换JSX元素为schema
        const jsxSchema = this.transformJSXElement(value.expression.right);

        // 为JSX元素添加条件
        jsxSchema.condition = {
          type: 'JSExpression',
          value: conditionValue,
        };

        return {
          type: 'JSSlot',
          value: [jsxSchema],
        };
      }

      return {
        type: 'JSExpression',
        value: this.transformLogicalExpression(value.expression),
      };
    }

    if (t.isJSXElement(value)) {
      logger(`【transformJSXAttributeValue】处理JSX元素`);
      return {
        type: 'JSSlot',
        value: [this.transformJSXElement(value)],
      };
    }

    if (t.isJSXExpressionContainer(value)) {
      const expression = value.expression;
      logger(`【transformJSXAttributeValue】处理JSX表达式容器，表达式类型: ${expression.type}`);

      // 特别关注条件表达式
      if (t.isConditionalExpression(expression)) {
        logger('🔥【CONDITIONAL_DEBUG】发现条件表达式！');
        logger('🔥【CONDITIONAL_DEBUG】test类型:', expression.test.type);
        logger('🔥【CONDITIONAL_DEBUG】consequent类型:', expression.consequent.type);
        logger('🔥【CONDITIONAL_DEBUG】alternate类型:', expression.alternate.type);
      }

      // 处理字面量值，直接返回原始值
      if (t.isNumericLiteral(expression)) {
        logger(`【transformJSXAttributeValue】处理数字字面量: ${expression.value}`);
        return expression.value;
      }
      if (t.isBooleanLiteral(expression)) {
        logger(`【transformJSXAttributeValue】处理布尔字面量: ${expression.value}`);
        return expression.value;
      }
      if (t.isStringLiteral(expression)) {
        logger(`【transformJSXAttributeValue】处理字符串字面量: "${expression.value}"`);
        return expression.value;
      }
      if (t.isNullLiteral(expression)) {
        logger(`【transformJSXAttributeValue】处理null字面量`);
        return null;
      }

      // 处理包含JSX的条件表达式
      if (t.isConditionalExpression(expression)) {
        logger('🎯【CONDITIONAL_PROCESSING】进入条件表达式处理逻辑！');
        logger(`【transformJSXAttributeValue】发现条件表达式，检查是否包含JSX`);
        const hasJSX = this.hasJSXInConditional(expression);
        logger(`【transformJSXAttributeValue】条件表达式包含JSX: ${hasJSX}`);

        if (hasJSX) {
          logger(`【transformJSXAttributeValue】条件表达式包含JSX，转换为JSSlot`);

          // 使用transformJSXChild来处理包含JSX的条件表达式
          const conditionalResult = this.transformJSXChild(
            {
              type: 'JSXExpressionContainer',
              expression: expression,
            },
            'conditionalRender', // 使用描述性的key
          );

          // transformJSXChild 返回的可能是数组或单个对象
          logger('🔥【CONDITIONAL_RESULT】transformJSXChild 返回结果:', conditionalResult);
          logger('🔥【CONDITIONAL_RESULT】是否为数组:', Array.isArray(conditionalResult));

          let finalResult;
          if (Array.isArray(conditionalResult)) {
            finalResult = {
              type: 'JSSlot',
              value: conditionalResult,
            };
          } else {
            finalResult = {
              type: 'JSSlot',
              value: [conditionalResult],
            };
          }

          logger('🔥【CONDITIONAL_RESULT】最终返回结果:', finalResult);
          return finalResult;
        } else {
          // 纯文本条件表达式，转换为JSExpression
          logger(`【transformJSXAttributeValue】纯文本条件表达式，转换为JSExpression`);
          return {
            type: 'JSExpression',
            value: this.transformJSExpression(expression),
          };
        }
      }

      // 处理立即执行的函数表达式（包括箭头函数和普通函数）
      if (
        t.isCallExpression(expression) &&
        (t.isArrowFunctionExpression(expression.callee) ||
          t.isFunctionExpression(expression.callee))
      ) {
        logger(`【transformJSXAttributeValue】处理立即执行的函数表达式 (IIFE)`);

        // 使用 transformJSExpression 来处理，确保正确添加 this 前缀
        const transformedValue = this.transformJSExpression(expression);
        logger(`【transformJSXAttributeValue】IIFE 转换结果:`, transformedValue);

        return {
          type: 'JSExpression',
          value: transformedValue,
        };
      }

      // 处理 function(...).bind(this) 表达式
      if (
        t.isCallExpression(expression) &&
        t.isMemberExpression(expression.callee) &&
        t.isIdentifier(expression.callee.property) &&
        expression.callee.property.name === 'bind' &&
        t.isFunctionExpression(expression.callee.object)
      ) {
        logger(`【transformJSXAttributeValue】处理 function(...).bind(this) 表达式`);
        const functionExpr = expression.callee.object;

        // 检查函数是否返回 JSX 元素
        const returnStatement = functionExpr.body.body.find((stmt) => t.isReturnStatement(stmt));
        if (
          returnStatement &&
          t.isReturnStatement(returnStatement) &&
          returnStatement.argument &&
          t.isJSXElement(returnStatement.argument)
        ) {
          logger(
            `【transformJSXAttributeValue】function(...).bind(this) 返回JSX元素，转换为JSSlot`,
          );

          // 提取函数参数名称，包括数组解构参数
          const params: string[] = [];
          functionExpr.params.forEach((param) => {
            if (t.isIdentifier(param)) {
              params.push(param.name);
            } else if (t.isArrayPattern(param)) {
              // 处理数组解构参数，如 [key, type]
              param.elements.forEach((element) => {
                if (t.isIdentifier(element)) {
                  params.push(element.name);
                }
              });
            } else {
              params.push('...'); // 对于其他复杂参数模式，简化处理
            }
          });

          logger(`【transformJSXAttributeValue】bind函数参数:`, params);

          // 保存当前的参数列表
          const prevSlotParams = [...this.currentSlotParams];
          // 更新当前的JSSlot参数
          this.currentSlotParams = params;

          logger(`【DEBUG】设置JSSlot参数:`, this.currentSlotParams);

          try {
            // 处理JSX元素，此时会使用currentSlotParams
            const jsxElement = this.transformJSXElement(returnStatement.argument);

            return {
              type: 'JSSlot',
              params: params?.length ? params : [''], // 添加params字段，包含函数参数名称
              value: [jsxElement],
            };
          } finally {
            // 恢复之前的参数列表
            this.currentSlotParams = prevSlotParams;
            logger(`【DEBUG】恢复JSSlot参数:`, this.currentSlotParams);
          }
        }
      }

      // 特殊处理Text组件的children属性，但首先检查是否为JSXElement
      if (componentName === 'Text' && attrName === 'children') {
        logger(`【transformJSXAttributeValue】特殊处理Text组件的children属性:`, expression);

        // 如果children是JSXElement，应该返回JSSlot而不是JSExpression
        if (t.isJSXElement(expression)) {
          logger(`【transformJSXAttributeValue】Text组件children是JSX元素，转换为JSSlot`);
          return {
            type: 'JSSlot',
            value: [this.transformJSXElement(expression)],
          };
        }

        // 获取表达式的原始代码
        const { code } = generate(expression);
        logger(`【transformJSXAttributeValue】Text组件children表达式原始代码: "${code}"`);
        logger(`【transformJSXAttributeValue】当前循环变量:`, this.currentLoopArgs);
        logger(`【transformJSXAttributeValue】当前JSSlot参数:`, this.currentSlotParams);

        // 添加调试代码，检查是否包含record
        if (code.includes('record')) {
          logger(
            `【DEBUG】发现record引用，检查是否在JSSlot参数中:`,
            this.currentSlotParams.includes('record'),
            '当前JSSlot参数:',
            this.currentSlotParams,
          );
        }

        // 处理循环变量引用，确保正确添加this前缀
        let expressionValue = code;

        // 先检查是否已经有重复的this前缀，如this.this.item，将其修正为this.item
        const thisRepeatPattern1 = /this\.this\./g;
        if (thisRepeatPattern1.test(expressionValue)) {
          logger(`【transformJSXAttributeValue】修复重复的this前缀`);
          expressionValue = expressionValue.replace(thisRepeatPattern1, 'this.');
        }

        // 检查当前循环变量和所有循环变量
        logger(`【transformJSXAttributeValue】当前循环变量:`, this.currentLoopArgs);
        logger(`【transformJSXAttributeValue】所有循环变量:`, this.allLoopArgs);

        // 替换形如 this.item 的引用为 item（临时替换，后面会再添加this前缀）
        this.allLoopArgs.forEach((arg) => {
          const thisPattern = new RegExp(`this\\.${arg}\\b`, 'g');
          if (thisPattern.test(expressionValue)) {
            logger(`【transformJSXAttributeValue】替换 this.${arg} 为 ${arg}`);
            expressionValue = expressionValue.replace(thisPattern, arg);
          }
        });

        // 处理JSSlot参数，移除已有的this前缀（如果有）
        this.currentSlotParams.forEach((param) => {
          const thisPattern = new RegExp(`this\\.${param}\\b`, 'g');
          if (thisPattern.test(expressionValue)) {
            logger(`【transformJSXAttributeValue】替换 this.${param} 为 ${param}`);
            expressionValue = expressionValue.replace(thisPattern, param);
          }
        });

        // 现在为所有循环变量添加this前缀
        this.allLoopArgs.forEach((arg) => {
          // 先处理带属性的循环变量，使用全局替换
          const argWithPropPattern = new RegExp(
            `\\b${arg}((?:\\?\\.|\\.)[\\w$]+(?:(?:\\?\\.|\\.)[\\w$]+)*)`,
            'g',
          );
          logger('argWithPropPattern: ', argWithPropPattern, expressionValue);

          // 直接进行全局替换，但要避免重复添加this前缀
          expressionValue = expressionValue.replace(argWithPropPattern, (match, p1) => {
            // 检查这个匹配是否已经有this前缀
            if (match.startsWith(`this.${arg}`)) {
              return match; // 已经有this前缀，保持不变
            }
            logger(
              `【transformJSXAttributeValue】为带属性的循环变量 ${arg} 添加this前缀: ${match} -> this.${arg}${p1}`,
            );
            return `this.${arg}${p1}`;
          });

          // 再处理独立的循环变量
          const argPattern = new RegExp(`\\b${arg}\\b(?!\\s*=)(?!\\.|\\\")`, 'g');
          expressionValue = expressionValue.replace(argPattern, (match, offset, str) => {
            // 检查前面是否已经有this前缀
            const beforeMatch = str.substring(Math.max(0, offset - 5), offset);
            if (beforeMatch.endsWith('this.')) {
              return match; // 已经有this前缀，保持不变
            }
            logger(
              `【transformJSXAttributeValue】为独立循环变量 ${arg} 添加this前缀: ${match} -> this.${arg}`,
            );
            return `this.${arg}`;
          });
        });

        // 为所有JSSlot参数添加this前缀
        this.currentSlotParams.forEach((param) => {
          // 匹配独立的JSSlot参数（不是作为对象属性的一部分）
          const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*=)(?!\\.|\\\")`, 'g');
          expressionValue = expressionValue.replace(paramPattern, (match, offset, str) => {
            // 使用安全检查
            if (this.shouldAddThisPrefix(str, param, offset)) {
              logger(`【transformJSXAttributeValue】为JSSlot参数 ${param} 添加this前缀`);
              return `this.${param}`;
            } else {
              return match; // 保持原样
            }
          });

          // 特别处理形如 record?.property 或 record.property 的情况
          const paramWithPropPattern = new RegExp(
            `\\b${param}((?:\\?\\.|\\.)[\\w$]+(?:(?:\\?\\.|\\.)[\\w$]+)*)`,
            'g',
          );
          expressionValue = expressionValue.replace(
            paramWithPropPattern,
            (match, prop, offset, str) => {
              // 使用安全检查
              if (this.shouldAddThisPrefix(str, param, offset)) {
                logger(`【transformJSXAttributeValue】为带属性的JSSlot参数 ${param} 添加this前缀`);
                return `this.${param}${prop}`;
              } else {
                return match; // 保持原样
              }
            },
          );
        });

        // 处理感叹号前缀，确保不会重复添加
        expressionValue = this.fixExclamationMarks(expressionValue);

        // 最后检查是否有重复的this前缀，如this.this.item，将其修正为this.item
        const thisRepeatPattern2 = /this\.this\./g;
        if (thisRepeatPattern2.test(expressionValue)) {
          logger(`【transformJSXAttributeValue】修复重复的this前缀`);
          expressionValue = expressionValue.replace(thisRepeatPattern2, 'this.');
        }

        logger(`【transformJSXAttributeValue】处理后的表达式值: "${expressionValue}"`);

        return {
          type: 'JSExpression',
          value: expressionValue,
        };
      }

      // 处理箭头函数
      if (t.isArrowFunctionExpression(expression)) {
        logger(`【transformJSXAttributeValue】处理箭头函数`);

        // 提取函数参数名称，包括数组解构参数
        const params: string[] = [];
        expression.params.forEach((param) => {
          if (t.isIdentifier(param)) {
            params.push(param.name);
          } else if (t.isArrayPattern(param)) {
            // 处理数组解构参数，如 [key, type]
            param.elements.forEach((element) => {
              if (t.isIdentifier(element)) {
                params.push(element.name);
              }
            });
          } else {
            params.push('...'); // 对于其他复杂参数模式，简化处理
          }
        });

        logger(`【transformJSXAttributeValue】箭头函数参数:`, params);

        // 保存当前的参数列表
        const prevSlotParams = [...this.currentSlotParams];
        // 更新当前的JSSlot参数
        this.currentSlotParams = params;

        logger(`【DEBUG】设置JSSlot参数:`, this.currentSlotParams);

        try {
          // 检查箭头函数是否返回JSX元素
          if (t.isJSXElement(expression.body)) {
            logger(`【transformJSXAttributeValue】箭头函数直接返回JSX元素，转换为JSSlot`);

            // 处理JSX元素，此时会使用currentSlotParams
            const jsxElement = this.transformJSXElement(expression.body);

            return {
              type: 'JSSlot',
              params: params?.length ? params : [''], // 添加params字段，包含函数参数名称
              value: [jsxElement],
            };
          }

          // 检查箭头函数是否直接返回条件表达式
          logger(`【transformJSXAttributeValue】检查箭头函数body类型: ${expression.body.type}`);
          if (t.isConditionalExpression(expression.body)) {
            logger(`【transformJSXAttributeValue】发现条件表达式，检查是否包含JSX`);
            const hasJSX = this.hasJSXInConditional(expression.body);
            logger(`【transformJSXAttributeValue】条件表达式包含JSX: ${hasJSX}`);

            if (hasJSX) {
              logger(
                `【transformJSXAttributeValue】箭头函数直接返回包含JSX的条件表达式，转换为JSSlot`,
              );

              // 处理条件表达式，使用transformJSXChild来处理
              const conditionalResult = this.transformJSXChild(
                {
                  type: 'JSXExpressionContainer',
                  expression: expression.body,
                },
                'render', // 使用默认的key
              );

              // transformJSXChild 返回的是数组，直接使用
              const slotValue = Array.isArray(conditionalResult)
                ? conditionalResult
                : [conditionalResult];

              return {
                type: 'JSSlot',
                params: params?.length ? params : [''], // 添加params字段
                value: slotValue,
              };
            }
          }

          // 检查箭头函数是否有函数体并返回JSX元素
          if (t.isBlockStatement(expression.body)) {
            const returnStatement = expression.body.body.find((stmt) => t.isReturnStatement(stmt));
            if (
              returnStatement &&
              t.isReturnStatement(returnStatement) &&
              returnStatement.argument &&
              t.isJSXElement(returnStatement.argument)
            ) {
              logger(`【transformJSXAttributeValue】箭头函数块中返回JSX元素，转换为JSSlot`);

              const jsxElement = this.transformJSXElement(returnStatement.argument as t.JSXElement);

              return {
                type: 'JSSlot',
                params: params?.length ? params : [''], // 添加params字段
                value: [jsxElement],
              };
            } else if (
              returnStatement &&
              t.isReturnStatement(returnStatement) &&
              returnStatement.argument &&
              t.isConditionalExpression(returnStatement.argument) &&
              this.hasJSXInConditional(returnStatement.argument)
            ) {
              logger(
                `【transformJSXAttributeValue】箭头函数块中返回包含JSX的条件表达式，转换为JSSlot`,
              );

              // 处理条件表达式，使用transformJSXChild来处理
              const conditionalResult = this.transformJSXChild(
                {
                  type: 'JSXExpressionContainer',
                  expression: returnStatement.argument,
                },
                'render', // 使用默认的key
              );

              // transformJSXChild 返回的是数组，直接使用
              const slotValue = Array.isArray(conditionalResult)
                ? conditionalResult
                : [conditionalResult];

              return {
                type: 'JSSlot',
                params: params?.length ? params : [''], // 添加params字段
                value: slotValue,
              };
            } else if (
              returnStatement &&
              t.isReturnStatement(returnStatement) &&
              returnStatement.argument &&
              t.isLogicalExpression(returnStatement.argument) &&
              t.isJSXElement(returnStatement.argument.right)
            ) {
              logger(
                `【transformJSXAttributeValue】箭头函数块中返回逻辑表达式包含JSX元素，转换为JSSlot`,
              );

              const jsxElement = this.transformJSXElement(
                returnStatement.argument.right as t.JSXElement,
              );

              return {
                type: 'JSSlot',
                params: params?.length ? params : [''], // 添加params字段
                value: [jsxElement],
              };
            }
          }
        } finally {
          // 恢复之前的参数列表
          this.currentSlotParams = prevSlotParams;
          logger(`【DEBUG】恢复JSSlot参数:`, this.currentSlotParams);
        }

        // 检查函数中是否包含循环变量引用
        const functionValue = this.transformArrowFunctionToNormalFunction(expression);
        logger(`【transformJSXAttributeValue】转换后的函数值:`, functionValue);

        // 检查当前循环变量
        const hasLoopVars = this.currentLoopArgs.some((arg) => functionValue.includes(arg));
        logger(`【transformJSXAttributeValue】是否包含循环变量:`, hasLoopVars);

        if (hasLoopVars) {
          // 如果包含循环变量，需要确保正确添加this前缀
          let processedValue = functionValue;
          logger('processedValue: ', processedValue);
          // 传递函数参数，确保函数参数不被错误添加this前缀
          processedValue = this.transformJSFunctionAddThis(processedValue, params);
          logger(`【transformJSXAttributeValue】处理后的函数值:`, processedValue);
          return {
            type: 'JSFunction',
            value: processedValue,
          };
        }

        return {
          type: 'JSFunction',
          value: functionValue,
        };
      }

      if (t.isJSXElement(expression)) {
        logger(`【transformJSXAttributeValue】处理JSX元素表达式`);
        return {
          type: 'JSSlot',
          value: [this.transformJSXElement(expression)],
        };
      }

      // 处理 map 函数调用，特别是返回包含 JSX 的对象的情况
      if (
        (t.isCallExpression(expression) || t.isOptionalCallExpression(expression)) &&
        (t.isMemberExpression(expression.callee) ||
          t.isOptionalMemberExpression(expression.callee)) &&
        t.isIdentifier(expression.callee.property) &&
        expression.callee.property.name === 'map'
      ) {
        logger(`【transformJSXAttributeValue】处理map函数调用`);
        const mapCallback = expression.arguments[0];

        if (t.isArrowFunctionExpression(mapCallback)) {
          // 检查 map 回调函数是否返回包含 JSX 的对象
          let returnValue: t.Node | null = null;

          if (t.isBlockStatement(mapCallback.body)) {
            // 函数体形式：(item) => { return { ... } }
            const returnStatement = mapCallback.body.body.find((stmt) => t.isReturnStatement(stmt));
            if (
              returnStatement &&
              t.isReturnStatement(returnStatement) &&
              returnStatement.argument
            ) {
              returnValue = returnStatement.argument;
            }
          } else {
            // 表达式形式：(item) => ({ ... })
            returnValue = mapCallback.body;
          }

          // 检查返回值是否是包含 JSX 的对象
          if (t.isObjectExpression(returnValue)) {
            const hasJSXProperty = returnValue.properties.some((prop) => {
              if (t.isObjectProperty(prop) && t.isJSXElement(prop.value)) {
                return true;
              }
              return false;
            });

            if (hasJSXProperty) {
              logger(`【transformJSXAttributeValue】map函数返回包含JSX的对象，转换为JSSlot`);

              // 处理 map 循环，类似于 transformJSXChild 中的逻辑
              const arrayExpr = expression.callee.object;
              const itemParam = mapCallback.params[0];
              const indexParam = mapCallback.params[1];

              // 保存之前的循环参数和解构变量状态
              const prevLoopArgs = [...this.currentLoopArgs];
              const prevDestructuredVars = [...this.currentDestructuredVars];
              const prevMappings = new Map(this.destructuredVarMappings);

              // 获取循环变量名
              let itemName: string;
              let indexName: string;

              if (t.isArrayPattern(itemParam)) {
                // 处理数组解构参数
                itemName = 'entry';
                indexName = t.isIdentifier(indexParam) ? indexParam.name : 'index';

                // 建立解构变量映射
                itemParam.elements.forEach((element, index) => {
                  if (t.isIdentifier(element)) {
                    const mapping = `this.${itemName}[${index}]`;
                    this.destructuredVarMappings.set(element.name, mapping);
                    this.currentDestructuredVars.push(element.name);
                    if (!this.allDestructuredVars.includes(element.name)) {
                      this.allDestructuredVars.push(element.name);
                    }
                  }
                });
              } else {
                itemName = t.isIdentifier(itemParam) ? itemParam.name : 'item';
                indexName = t.isIdentifier(indexParam) ? indexParam.name : 'index';
              }

              // 更新循环变量
              this.currentLoopArgs = [...prevLoopArgs, itemName, indexName];
              if (!this.allLoopArgs.includes(itemName)) {
                this.allLoopArgs.push(itemName);
              }
              if (!this.allLoopArgs.includes(indexName)) {
                this.allLoopArgs.push(indexName);
              }

              try {
                // 找到包含 JSX 的属性并转换
                const jsxProperty = returnValue.properties.find((prop) => {
                  return t.isObjectProperty(prop) && t.isJSXElement(prop.value);
                }) as t.ObjectProperty;

                if (jsxProperty && t.isJSXElement(jsxProperty.value)) {
                  const jsxElement = this.transformJSXElement(jsxProperty.value);

                  // 添加循环信息
                  const arrayExprCode = generate(arrayExpr).code;
                  jsxElement.loop = {
                    type: 'JSExpression',
                    value: arrayExprCode,
                  };
                  jsxElement.loopArgs = [itemName, indexName];

                  return {
                    type: 'JSSlot',
                    value: [jsxElement],
                  };
                }
              } finally {
                // 恢复之前的状态
                this.currentLoopArgs = prevLoopArgs;
                this.currentDestructuredVars = prevDestructuredVars;
                this.destructuredVarMappings = prevMappings;
              }
            }
          }
        }
      }

      if (t.isArrayExpression(expression)) {
        // 添加日志
        logger(`【transformJSXAttributeValue】处理数组表达式:`, expression);

        // 使用新的方法处理数组表达式
        return this.transformArrayExpression(expression);
      }

      if (t.isObjectExpression(expression)) {
        logger(`【transformJSXAttributeValue】处理对象表达式`);
        const obj: any = {};
        expression.properties.forEach((prop) => {
          // 处理 ObjectMethod（如 render(text, record) { ... }）
          if (t.isObjectMethod(prop)) {
            const key = t.isIdentifier(prop.key)
              ? prop.key.name
              : t.isStringLiteral(prop.key)
              ? prop.key.value
              : '';
            if (key) {
              logger(`【transformJSXAttributeValue】处理对象方法: ${key}`);

              // 提取函数参数名称，包括数组解构参数
              const params: string[] = [];
              prop.params.forEach((param) => {
                if (t.isIdentifier(param)) {
                  params.push(param.name);
                } else if (t.isArrayPattern(param)) {
                  // 处理数组解构参数，如 [key, type]
                  param.elements.forEach((element) => {
                    if (t.isIdentifier(element)) {
                      params.push(element.name);
                    }
                  });
                } else {
                  params.push('...'); // 对于其他复杂参数模式，简化处理
                }
              });

              // 保存当前的参数列表
              const prevSlotParams = [...this.currentSlotParams];
              // 更新当前的JSSlot参数
              this.currentSlotParams = params;

              try {
                // 检查函数体中的return语句是否返回JSX元素或包含JSX的条件表达式
                const returnStatement = prop.body.body.find((stmt) => t.isReturnStatement(stmt));
                if (
                  returnStatement &&
                  t.isReturnStatement(returnStatement) &&
                  returnStatement.argument &&
                  (t.isJSXElement(returnStatement.argument) ||
                    (t.isConditionalExpression(returnStatement.argument) &&
                      this.hasJSXInConditional(returnStatement.argument)))
                ) {
                  logger(
                    `【transformJSXAttributeValue】对象方法返回JSX元素或包含JSX的条件表达式，转换为JSSlot`,
                  );
                  let slotValue;
                  if (t.isJSXElement(returnStatement.argument)) {
                    slotValue = [this.transformJSXElement(returnStatement.argument)];
                  } else if (t.isConditionalExpression(returnStatement.argument)) {
                    // 处理三元表达式，使用transformJSXChild来处理条件表达式
                    slotValue = this.transformJSXChild(
                      {
                        type: 'JSXExpressionContainer',
                        expression: returnStatement.argument,
                      },
                      key,
                    );
                  } else {
                    slotValue = [
                      this.transformJSXElement(returnStatement.argument as t.JSXElement),
                    ];
                  }
                  obj[key] = {
                    type: 'JSSlot',
                    params: params?.length ? params : [''], // 添加params字段
                    value: slotValue,
                  };
                } else {
                  // 普通方法，使用JSFunction
                  logger(`【transformJSXAttributeValue】对象方法，转换为JSFunction`);
                  // 将 ObjectMethod 转换为 FunctionExpression 字符串
                  const methodCode = generate(prop).code;
                  obj[key] = {
                    type: 'JSFunction',
                    value: methodCode,
                  };
                }
              } finally {
                // 恢复之前的参数列表
                this.currentSlotParams = prevSlotParams;
              }
            }
          } else if (t.isObjectProperty(prop)) {
            const key = t.isIdentifier(prop.key)
              ? prop.key.name
              : t.isStringLiteral(prop.key)
              ? prop.key.value
              : '';
            if (key) {
              logger(
                `【transformJSXAttributeValue】处理对象属性: ${key}, 值类型: ${prop.value.type}`,
              );
              // 处理对象属性中的字面量值
              if (t.isNumericLiteral(prop.value)) {
                obj[key] = prop.value.value;
              } else if (t.isBooleanLiteral(prop.value)) {
                obj[key] = prop.value.value;
              } else if (t.isStringLiteral(prop.value)) {
                obj[key] = prop.value.value;
              } else if (t.isNullLiteral(prop.value)) {
                obj[key] = null;
              } else if (t.isJSXExpressionContainer(prop.value)) {
                const exprContainer = prop.value as t.JSXExpressionContainer;
                logger(this.transformJSExpression(exprContainer.expression));
                obj[key] = {
                  type: 'JSExpression',
                  value: this.transformJSExpression(exprContainer.expression),
                };
              } else if (t.isMemberExpression(prop.value)) {
                obj[key] = {
                  type: 'JSExpression',
                  value: this.transformJSExpression(prop.value),
                };

                logger(this.transformJSExpression(prop.value));
              } else if (t.isObjectExpression(prop.value)) {
                obj[key] = this.transformJSXAttributeValue({
                  type: 'JSXExpressionContainer',
                  expression: prop.value,
                });
              } else if (t.isArrayExpression(prop.value)) {
                // 直接处理数组，不转换为字符串形式的JSExpression
                logger(`【transformJSXAttributeValue】对象属性中的数组:`, prop.value);
                obj[key] = this.transformArrayExpression(prop.value);
              } else if (
                t.isArrowFunctionExpression(prop.value) ||
                t.isFunctionExpression(prop.value)
              ) {
                logger(`【transformJSXAttributeValue】对象属性中的函数:`, prop.value);

                // 提取函数参数名称，包括数组解构参数
                const params: string[] = [];
                prop.value.params.forEach((param) => {
                  if (t.isIdentifier(param)) {
                    params.push(param.name);
                  } else if (t.isArrayPattern(param)) {
                    // 处理数组解构参数，如 [key, type]
                    param.elements.forEach((element) => {
                      if (t.isIdentifier(element)) {
                        params.push(element.name);
                      }
                    });
                  } else {
                    params.push('...'); // 对于其他复杂参数模式，简化处理
                  }
                });

                // 保存当前的参数列表
                const prevSlotParams = [...this.currentSlotParams];
                // 更新当前的JSSlot参数
                this.currentSlotParams = params;

                try {
                  // 对于FunctionExpression，检查是否返回JSX元素
                  if (t.isFunctionExpression(prop.value)) {
                    logger(`【transformJSXAttributeValue】普通函数表达式，检查返回值类型`);

                    // 检查函数体中的return语句是否返回JSX元素
                    const returnStatement = prop.value.body.body.find((stmt) =>
                      t.isReturnStatement(stmt),
                    );
                    if (
                      returnStatement &&
                      t.isReturnStatement(returnStatement) &&
                      returnStatement.argument &&
                      (t.isJSXElement(returnStatement.argument) ||
                        (t.isConditionalExpression(returnStatement.argument) &&
                          this.hasJSXInConditional(returnStatement.argument)))
                    ) {
                      logger(
                        `【transformJSXAttributeValue】普通函数表达式返回JSX元素或包含JSX的条件表达式，转换为JSSlot`,
                      );
                      let slotValue;
                      if (t.isJSXElement(returnStatement.argument)) {
                        slotValue = [this.transformJSXElement(returnStatement.argument)];
                      } else if (t.isConditionalExpression(returnStatement.argument)) {
                        // 处理三元表达式，使用transformJSXChild来处理条件表达式
                        const conditionalResult = this.transformJSXChild(
                          {
                            type: 'JSXExpressionContainer',
                            expression: returnStatement.argument,
                          },
                          key,
                        );

                        // transformJSXChild 返回的是数组，直接使用
                        slotValue = Array.isArray(conditionalResult)
                          ? conditionalResult
                          : [conditionalResult];
                      } else {
                        slotValue = [
                          this.transformJSXElement(returnStatement.argument as t.JSXElement),
                        ];
                      }
                      obj[key] = {
                        type: 'JSSlot',
                        params: params?.length ? params : [''], // 添加params字段
                        value: slotValue,
                      };
                    } else if (
                      returnStatement &&
                      t.isReturnStatement(returnStatement) &&
                      returnStatement.argument &&
                      t.isLogicalExpression(returnStatement.argument) &&
                      t.isJSXElement(returnStatement.argument.right)
                    ) {
                      logger(
                        `【transformJSXAttributeValue】普通函数表达式返回逻辑表达式包含JSX元素，转换为JSSlot`,
                      );
                      obj[key] = {
                        type: 'JSSlot',
                        params: params?.length ? params : [''], // 添加params字段
                        value: [
                          this.transformJSXElement(returnStatement.argument.right as t.JSXElement),
                        ],
                      };
                    } else if (
                      returnStatement &&
                      t.isReturnStatement(returnStatement) &&
                      returnStatement.argument &&
                      t.isArrayExpression(returnStatement.argument)
                    ) {
                      const hasJSXElement = returnStatement.argument.elements.some(
                        (element) => element && t.isJSXElement(element),
                      );
                      if (hasJSXElement) {
                        logger(
                          `【transformJSXAttributeValue】普通函数表达式返回JSX元素数组，转换为JSSlot`,
                        );
                        // 将数组中的JSX元素转换为JSSlot
                        const jsxElements = returnStatement.argument.elements
                          .filter((element) => element && t.isJSXElement(element))
                          .map((element) => this.transformJSXElement(element as t.JSXElement));

                        obj[key] = {
                          type: 'JSSlot',
                          params: params?.length ? params : [''], // 添加params字段
                          value: jsxElements,
                        };
                      } else {
                        // 普通函数，使用JSFunction
                        logger(`【transformJSXAttributeValue】普通函数表达式，转换为JSFunction`);
                        obj[key] = {
                          type: 'JSFunction',
                          value: this.transformJSExpression(prop.value),
                        };
                      }
                    } else {
                      // 普通函数，使用JSFunction
                      logger(`【transformJSXAttributeValue】普通函数表达式，转换为JSFunction`);
                      obj[key] = {
                        type: 'JSFunction',
                        value: this.transformJSExpression(prop.value),
                      };
                    }
                  }
                  // 检查箭头函数是否直接返回条件表达式
                  else if (
                    t.isConditionalExpression(prop.value.body) &&
                    this.hasJSXInConditional(prop.value.body)
                  ) {
                    logger(
                      `【transformJSXAttributeValue】对象属性中的箭头函数直接返回包含JSX的条件表达式，转换为JSSlot`,
                    );

                    // 处理条件表达式，使用transformJSXChild来处理
                    const conditionalResult = this.transformJSXChild(
                      {
                        type: 'JSXExpressionContainer',
                        expression: prop.value.body,
                      },
                      key,
                    );

                    // transformJSXChild 返回的是数组，直接使用
                    const slotValue = Array.isArray(conditionalResult)
                      ? conditionalResult
                      : [conditionalResult];

                    obj[key] = {
                      type: 'JSSlot',
                      params: params?.length ? params : [''], // 添加params字段
                      value: slotValue,
                    };
                  }
                  // 检查箭头函数是否返回JSX元素数组
                  else if (t.isArrayExpression(prop.value.body)) {
                    const hasJSXElement = prop.value.body.elements.some(
                      (element) => element && t.isJSXElement(element),
                    );
                    if (hasJSXElement) {
                      logger(`【transformJSXAttributeValue】箭头函数返回JSX元素数组，转换为JSSlot`);
                      // 将数组中的JSX元素转换为JSSlot
                      const jsxElements = prop.value.body.elements
                        .filter((element) => element && t.isJSXElement(element))
                        .map((element) => this.transformJSXElement(element as t.JSXElement));

                      obj[key] = {
                        type: 'JSSlot',
                        params: params?.length ? params : [''], // 添加params字段
                        value: jsxElements,
                      };
                    } else {
                      // 普通箭头函数，使用JSExpression
                      obj[key] = {
                        type: 'JSExpression',
                        value: this.transformJSExpression(prop.value),
                      };
                    }
                  } else if (t.isBlockStatement(prop.value.body)) {
                    // 检查函数体中的return语句是否返回JSX元素数组
                    const returnStatement = prop.value.body.body.find((stmt) =>
                      t.isReturnStatement(stmt),
                    );
                    if (
                      returnStatement &&
                      t.isReturnStatement(returnStatement) &&
                      returnStatement.argument &&
                      t.isArrayExpression(returnStatement.argument)
                    ) {
                      const hasJSXElement = returnStatement.argument.elements.some(
                        (element) => element && t.isJSXElement(element),
                      );

                      if (hasJSXElement) {
                        logger(
                          `【transformJSXAttributeValue】箭头函数块中返回JSX元素数组，转换为JSSlot`,
                        );
                        // 将数组中的JSX元素转换为JSSlot
                        const jsxElements = returnStatement.argument.elements
                          .filter((element) => element && t.isJSXElement(element))
                          .map((element) => this.transformJSXElement(element as t.JSXElement));

                        obj[key] = {
                          type: 'JSSlot',
                          params: params?.length ? params : [''], // 添加params字段
                          value: jsxElements,
                        };
                      } else {
                        // 普通箭头函数，使用JSExpression
                        obj[key] = {
                          type: 'JSExpression',
                          value: this.transformJSExpression(prop.value),
                        };
                      }
                    } else if (
                      returnStatement &&
                      t.isReturnStatement(returnStatement) &&
                      returnStatement.argument &&
                      t.isJSXElement(returnStatement.argument)
                    ) {
                      // 处理返回单个JSX元素的情况
                      logger(
                        `【transformJSXAttributeValue】箭头函数块中返回单个JSX元素，转换为JSSlot`,
                      );
                      obj[key] = {
                        type: 'JSSlot',
                        params: params?.length ? params : [''], // 添加params字段
                        value: [this.transformJSXElement(returnStatement.argument as t.JSXElement)],
                      };
                    } else if (
                      returnStatement &&
                      t.isReturnStatement(returnStatement) &&
                      returnStatement.argument &&
                      t.isConditionalExpression(returnStatement.argument) &&
                      this.hasJSXInConditional(returnStatement.argument)
                    ) {
                      // 处理返回包含JSX的条件表达式的情况
                      logger(
                        `【transformJSXAttributeValue】对象属性中的箭头函数块中返回包含JSX的条件表达式，转换为JSSlot`,
                      );

                      // 处理条件表达式，使用transformJSXChild来处理
                      const conditionalResult = this.transformJSXChild(
                        {
                          type: 'JSXExpressionContainer',
                          expression: returnStatement.argument,
                        },
                        key,
                      );

                      // transformJSXChild 返回的是数组，直接使用
                      const slotValue = Array.isArray(conditionalResult)
                        ? conditionalResult
                        : [conditionalResult];

                      obj[key] = {
                        type: 'JSSlot',
                        params: params?.length ? params : [''], // 添加params字段
                        value: slotValue,
                      };
                    } else if (
                      returnStatement &&
                      t.isReturnStatement(returnStatement) &&
                      returnStatement.argument &&
                      t.isLogicalExpression(returnStatement.argument) &&
                      t.isJSXElement(returnStatement.argument.right)
                    ) {
                      // 处理返回逻辑表达式包含JSX元素的情况
                      logger(
                        `【transformJSXAttributeValue】箭头函数块中返回逻辑表达式包含JSX元素，转换为JSSlot`,
                      );
                      obj[key] = {
                        type: 'JSSlot',
                        params: params?.length ? params : [''], // 添加params字段
                        value: [
                          this.transformJSXElement(returnStatement.argument.right as t.JSXElement),
                        ],
                      };
                    } else {
                      // 普通箭头函数，使用JSExpression
                      obj[key] = {
                        type: 'JSExpression',
                        value: this.transformJSExpression(prop.value),
                      };
                    }
                  } else if (t.isJSXElement(prop.value.body)) {
                    // 处理直接返回JSX元素的箭头函数
                    logger(`【transformJSXAttributeValue】箭头函数直接返回JSX元素，转换为JSSlot`);
                    obj[key] = {
                      type: 'JSSlot',
                      params: params?.length ? params : [''], // 添加params字段
                      value: [this.transformJSXElement(prop.value.body)],
                    };
                  } else if (
                    t.isLogicalExpression(prop.value.body) &&
                    t.isJSXElement(prop.value.body.right)
                  ) {
                    // 处理直接返回逻辑表达式包含JSX元素的箭头函数
                    logger(
                      `【transformJSXAttributeValue】箭头函数直接返回逻辑表达式包含JSX元素，转换为JSSlot`,
                    );
                    obj[key] = {
                      type: 'JSSlot',
                      params: params?.length ? params : [''], // 添加params字段
                      value: [this.transformJSXElement(prop.value.body.right)],
                    };
                  } else {
                    // 普通箭头函数，使用JSExpression
                    obj[key] = {
                      type: 'JSExpression',
                      value: this.transformJSExpression(prop.value),
                    };
                  }
                } finally {
                  // 恢复之前的参数列表
                  this.currentSlotParams = prevSlotParams;
                }
              } else if (
                t.isCallExpression(prop.value) &&
                t.isMemberExpression(prop.value.callee) &&
                t.isIdentifier(prop.value.callee.property) &&
                prop.value.callee.property.name === 'bind' &&
                t.isFunctionExpression(prop.value.callee.object)
              ) {
                logger(
                  `【transformJSXAttributeValue】对象属性中的 function(...).bind(this):`,
                  prop.value,
                );

                const functionExpr = prop.value.callee.object;

                // 检查函数是否返回 JSX 元素
                const returnStatement = functionExpr.body.body.find((stmt) =>
                  t.isReturnStatement(stmt),
                );
                if (
                  returnStatement &&
                  t.isReturnStatement(returnStatement) &&
                  returnStatement.argument &&
                  t.isJSXElement(returnStatement.argument)
                ) {
                  logger(
                    `【transformJSXAttributeValue】对象属性中的 function(...).bind(this) 返回JSX元素，转换为JSSlot`,
                  );

                  // 提取函数参数名称，包括数组解构参数
                  const params: string[] = [];
                  functionExpr.params.forEach((param) => {
                    if (t.isIdentifier(param)) {
                      params.push(param.name);
                    } else if (t.isArrayPattern(param)) {
                      // 处理数组解构参数，如 [key, type]
                      param.elements.forEach((element) => {
                        if (t.isIdentifier(element)) {
                          params.push(element.name);
                        }
                      });
                    } else {
                      params.push('...'); // 对于其他复杂参数模式，简化处理
                    }
                  });

                  // 保存当前的参数列表
                  const prevSlotParams = [...this.currentSlotParams];
                  // 更新当前的JSSlot参数
                  this.currentSlotParams = params;

                  try {
                    // 处理JSX元素，此时会使用currentSlotParams
                    const jsxElement = this.transformJSXElement(returnStatement.argument);

                    obj[key] = {
                      type: 'JSSlot',
                      params: params?.length ? params : [''], // 添加params字段，包含函数参数名称
                      value: [jsxElement],
                    };
                  } finally {
                    // 恢复之前的参数列表
                    this.currentSlotParams = prevSlotParams;
                  }
                } else {
                  // 如果不是返回JSX的函数，则作为普通JSExpression处理
                  obj[key] = {
                    type: 'JSExpression',
                    value: this.transformJSExpression(prop.value),
                  };
                }
              } else {
                let transformedValue;
                if (
                  t.isStringLiteral(prop.value) ||
                  t.isJSXElement(prop.value) ||
                  (typeof t.isJSXFragment === 'function' && t.isJSXFragment(prop.value)) ||
                  t.isJSXExpressionContainer(prop.value) ||
                  prop.value === null
                ) {
                  // 只有这几种类型才安全传递
                  transformedValue = this.transformJSXAttributeValue(
                    prop.value as t.JSXAttribute['value'],
                  );
                } else if (t.isExpression(prop.value)) {
                  transformedValue = {
                    type: 'JSExpression',
                    value: this.transformJSExpression(prop.value as t.Expression),
                  };
                } else {
                  // 其它类型兜底
                  transformedValue = {
                    type: 'JSExpression',
                    value: '/* 处理错误 */',
                  };
                }
                obj[key] = transformedValue;
              }
            }
          }
        });
        logger(`【transformJSXAttributeValue】生成的对象:`, obj);
        return obj;
      }

      // 恢复被删除的代码
      if (t.isMemberExpression(expression)) {
        logger(`【transformJSXAttributeValue】处理成员表达式`);
        const result = {
          type: 'JSExpression',
          value: this.transformJSExpression(expression),
        };
        logger(`【transformJSXAttributeValue】成员表达式结果:`, result.value);
        return result;
      }

      // 对于其他类型的表达式，仍然需要转换为JSExpression
      logger(`【transformJSXAttributeValue】处理其他类型表达式: ${expression.type}`);
      const result = {
        type: 'JSExpression',
        value: this.transformJSExpression(expression),
      };
      logger(`【transformJSXAttributeValue】其他表达式结果:`, result.value);
      return result;
    }

    logger(`【transformJSXAttributeValue】未处理的属性值类型: ${value?.type || 'undefined'}`);
    return undefined;
  }

  // 添加一个新方法专门用于处理数组表达式，返回实际的数组而不是字符串
  private transformArrayExpression(expr: t.ArrayExpression): any[] {
    logger('transformArrayExpression 处理数组:', expr);

    return expr.elements.map((element) => {
      if (!element) return null;

      if (t.isStringLiteral(element)) {
        logger('数组中的字符串:', element.value);
        return element.value;
      }

      if (t.isNumericLiteral(element)) {
        logger('数组中的数字:', element.value);
        return element.value;
      }

      if (t.isBooleanLiteral(element)) {
        logger('数组中的布尔值:', element.value);
        return element.value;
      }

      if (t.isNullLiteral(element)) {
        logger('数组中的null');
        return null;
      }

      if (t.isJSXElement(element)) {
        logger('数组中的JSX元素');
        return {
          type: 'JSSlot',
          value: [this.transformJSXElement(element)],
        };
      }

      if (t.isObjectExpression(element)) {
        logger('数组中的对象');
        return this.transformJSXAttributeValue({
          type: 'JSXExpressionContainer',
          expression: element,
        });
      }

      if (t.isMemberExpression(element)) {
        logger('数组中的成员表达式', this.transformJSExpression(element));
        return {
          type: 'JSExpression',
          value: this.transformJSExpression(element),
        };
      }

      // 对于其他类型，使用JSExpression
      logger('数组中的其他类型表达式', this.transformJSExpression(element));
      return {
        type: 'JSExpression',
        value: this.transformJSExpression(element),
      };
    });
  }

  private transformJSExpression(
    expr:
      | t.Expression
      | t.JSXEmptyExpression
      | t.SpreadElement
      | t.OptionalCallExpression
      | t.FunctionExpression
      | t.PrivateName,
  ): string {
    logger(`【transformJSExpression】开始处理表达式，类型: ${expr.type}`);
    logger('【transformJSExpression】表达式完整信息:', expr);

    // 处理 PrivateName 类型
    if (t.isPrivateName && t.isPrivateName(expr)) {
      logger(`【transformJSExpression】处理私有名称: #${expr.id.name}`);
      return `#${expr.id.name}`;
    }

    if (t.isJSXEmptyExpression(expr)) {
      logger(`【transformJSExpression】处理空表达式`);
      return '';
    }

    // 处理展开运算符
    if (expr.type === 'SpreadElement') {
      logger(`【transformJSExpression】处理展开运算符`);
      // 使用类型断言确保TypeScript知道这是SpreadElement类型
      const spreadExpr = expr as unknown as { argument: t.Expression };
      const argument = this.transformJSExpression(spreadExpr.argument);
      return `...${argument}`;
    }

    if (t.isIdentifier(expr)) {
      // 检查是否是解构变量（优先级最高）
      const isDestructuredVar = this.allDestructuredVars.includes(expr.name);
      const isLoopArg = this.allLoopArgs.includes(expr.name);
      const isSlotParam = this.currentSlotParams.includes(expr.name);
      const isFunctionParam = this.currentFunctionParams.includes(expr.name);
      logger(
        `【transformJSExpression】处理标识符: ${expr.name}, 是否是解构变量: ${isDestructuredVar}, 是否是循环变量: ${isLoopArg}, 是否是JSSlot参数: ${isSlotParam}, 是否是函数参数: ${isFunctionParam}`,
      );

      // 如果是解构变量，使用映射的数组访问形式
      if (isDestructuredVar) {
        const mapping = this.destructuredVarMappings.get(expr.name);
        if (mapping) {
          logger(`【transformJSExpression】替换解构变量 ${expr.name} 为 ${mapping}`);
          return mapping;
        }
      }

      // 如果是函数参数，直接返回，不添加this前缀
      if (isFunctionParam) {
        logger(`【transformJSExpression】${expr.name} 是函数参数，不添加this前缀`);
        return expr.name;
      }

      // 如果是循环参数或JSSlot参数，需要添加 this 前缀
      if (isLoopArg || isSlotParam) {
        logger(`【transformJSExpression】为变量 ${expr.name} 添加this前缀`);
        return `this.${expr.name}`;
      }
      // 检查是否是对象属性访问中的循环参数
      if (expr.name === 'this') {
        return 'this';
      }

      // 添加调试代码，检查是否是record
      if (expr.name === 'record') {
        logger(
          `【DEBUG】发现record标识符，但不在JSSlot参数中:`,
          this.currentSlotParams.includes('record'),
          '当前JSSlot参数:',
          this.currentSlotParams,
        );
      }

      return expr.name;
    }

    if (t.isStringLiteral(expr)) {
      logger(`【transformJSExpression】处理字符串字面量: "${expr.value}"`);
      return JSON.stringify(expr.value);
    }

    if (t.isNumericLiteral(expr)) {
      logger(`【transformJSExpression】处理数字字面量: ${expr.value}`);
      return String(expr.value);
    }

    if (t.isBooleanLiteral(expr)) {
      logger(`【transformJSExpression】处理布尔字面量: ${expr.value}`);
      return expr.value ? 'true' : 'false';
    }

    if (t.isNullLiteral(expr)) {
      logger(`【transformJSExpression】处理null字面量`);
      return 'null';
    }

    if (t.isRegExpLiteral(expr)) {
      logger(`【transformJSExpression】处理正则表达式字面量: /${expr.pattern}/${expr.flags}`);
      return `/${expr.pattern}/${expr.flags}`;
    }

    if (t.isThisExpression(expr)) {
      logger(`【transformJSExpression】处理this表达式`);
      return 'this';
    }

    // 添加对箭头函数的处理
    if (t.isArrowFunctionExpression(expr)) {
      logger(`【transformJSExpression】处理箭头函数`);
      return this.transformArrowFunctionToNormalFunction(expr);
    }

    // 添加对普通函数表达式的处理
    if (t.isFunctionExpression(expr)) {
      logger(`【transformJSExpression】处理普通函数表达式`);
      return this.transformFunctionExpressionToString(expr);
    }

    if (t.isArrayExpression(expr)) {
      // 添加日志
      logger(`【transformJSExpression】处理数组表达式:`, expr);

      // 注意：这个方法返回的是字符串表示，用于JSExpression的value
      // 如果需要实际的数组对象，应该使用transformArrayExpression方法
      const elements = expr.elements.map((element) => {
        if (!element) return 'null';

        // 安全处理不同类型的元素
        try {
          if (t.isExpression(element)) {
            return this.transformJSExpression(element);
          }
          return 'null';
        } catch (error) {
          console.error(`【transformJSExpression】处理数组元素时出错:`, error);
          return 'null';
        }
      });
      // 这里可能是问题所在，我们返回了字符串形式的数组
      logger(`【transformJSExpression】数组元素字符串:`, elements);
      return `[${elements.join(', ')}]`;
    }

    if (t.isObjectExpression(expr)) {
      logger(`【transformJSExpression】处理对象表达式`);
      const properties = expr.properties.map((prop) => {
        if (t.isObjectProperty(prop)) {
          let key = t.isIdentifier(prop.key) ? prop.key.name : `"${(prop.key as any).value}"`;

          // 处理简写属性
          if (prop.shorthand) {
            // 如果是简写属性，我们需要把它展开
            // 例如 { index } 需要变成 { index: this.index }
            if (t.isExpression(prop.value)) {
              const value = this.transformJSExpression(prop.value);
              return `${key}: ${value}`;
            }
            return `${key}: ${key}`;
          }

          if (t.isExpression(prop.value)) {
            let value = this.transformJSExpression(prop.value);
            return `${key}: ${value}`;
          }
          return `${key}: undefined`;
        }
        // 其它类型（如 ArrayPattern、RestElement、SpreadElement 等）直接跳过
        return '';
      });
      return `{ ${properties.filter(Boolean).join(', ')} }`;
    }

    if (t.isMemberExpression(expr) || t.isOptionalMemberExpression(expr)) {
      const object = expr.object;
      const property = expr.property;
      const optional = expr.optional;
      const computed = expr.computed; // 是否是计算属性（使用中括号）

      logger(
        `【transformJSExpression】处理成员表达式，对象类型: ${object.type}, 属性类型: ${property.type}, 是否计算属性: ${computed}`,
      );

      // 处理this表达式
      if (t.isThisExpression(object) && t.isIdentifier(property)) {
        logger(`【transformJSExpression】处理this成员表达式: this.${property.name}`);
        return `this${optional ? '?.' : '.'}${property.name}`;
      }

      // 处理嵌套成员表达式
      if (t.isMemberExpression(object)) {
        const objectStr = this.transformJSExpression(object);

        // 处理计算属性（使用中括号访问）
        if (computed) {
          const propExpr = t.isExpression(property)
            ? this.transformJSExpression(property)
            : property.toString();
          logger(`【transformJSExpression】处理计算成员表达式: ${objectStr}[${propExpr}]`);

          // 检查属性表达式中是否包含循环变量
          let propExprStr = propExpr;
          this.allLoopArgs.forEach((arg) => {
            // 如果属性表达式中直接使用了循环变量（没有this前缀），添加this前缀
            const argPattern = new RegExp(`\\b${arg}\\b(?!\\s*[:=])(?!\\.|\\\")`, 'g');
            if (argPattern.test(propExprStr) && !propExprStr.includes(`this.${arg}`)) {
              logger(`【transformJSExpression】在索引表达式中为循环变量 ${arg} 添加this前缀`);
              propExprStr = propExprStr.replace(argPattern, `this.${arg}`);
            }

            // 特别处理形如 item?.property 或 item.property 的情况
            const argWithPropPattern = new RegExp(
              `\\b${arg}((?:\\?\\.|\\.)[\\w$]+(?:(?:\\?\\.|\\.)[\\w$]+)*)`,
              'g',
            );
            if (argWithPropPattern.test(propExprStr) && !propExprStr.includes(`this.${arg}`)) {
              logger(
                `【transformJSExpression】在索引表达式中为带属性的循环变量 ${arg} 添加this前缀`,
              );
              propExprStr = propExprStr.replace(argWithPropPattern, `this.${arg}$1`);
            }
          });

          // 检查属性表达式中是否包含JSSlot参数
          this.currentSlotParams.forEach((param) => {
            // 如果属性表达式中直接使用了JSSlot参数（没有this前缀），添加this前缀
            const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*[:=])(?!\\.|\\\")`, 'g');
            if (paramPattern.test(propExprStr) && !propExprStr.includes(`this.${param}`)) {
              logger(`【transformJSExpression】在索引表达式中为JSSlot参数 ${param} 添加this前缀`);
              propExprStr = propExprStr.replace(paramPattern, `this.${param}`);
            }

            // 特别处理形如 record?.property 或 record.property 的情况
            const paramWithPropPattern = new RegExp(
              `\\b${param}((?:\\?\\.|\\.)[\\w$]+(?:(?:\\?\\.|\\.)[\\w$]+)*)`,
              'g',
            );
            if (paramWithPropPattern.test(propExprStr) && !propExprStr.includes(`this.${param}`)) {
              logger(
                `【transformJSExpression】在索引表达式中为带属性的JSSlot参数 ${param} 添加this前缀`,
              );
              propExprStr = propExprStr.replace(paramWithPropPattern, `this.${param}$1`);
            }
          });

          return `${objectStr}${optional ? '?.' : ''}[${propExprStr}]`;
        }

        // 处理普通属性（使用点访问）
        let propStr = '';
        if (t.isIdentifier(property)) {
          propStr = property.name;
        } else if (t.isExpression(property)) {
          propStr = this.transformJSExpression(property);
        } else {
          propStr = property.toString();
        }

        logger(`【transformJSExpression】处理嵌套成员表达式: ${objectStr}.${propStr}`);
        return `${objectStr}${optional ? '?.' : '.'}${propStr}`;
      }

      // 处理标识符
      if (t.isIdentifier(object)) {
        // 检查对象是否是循环参数、JSSlot参数或解构变量
        const isObjectLoopArg = this.allLoopArgs.includes(object.name);
        const isObjectSlotParam = this.currentSlotParams.includes(object.name);
        const isObjectDestructuredVar = this.currentDestructuredVars.includes(object.name);
        const destructuredMapping = this.destructuredVarMappings.get(object.name);

        logger(
          `【transformJSExpression】处理标识符成员表达式: ${object.name}, 是否是循环变量: ${isObjectLoopArg}, 是否是JSSlot参数: ${isObjectSlotParam}, 是否是解构变量: ${isObjectDestructuredVar}, 解构映射: ${destructuredMapping}, 当前循环变量:`,
          this.currentLoopArgs,
          '所有循环变量:',
          this.allLoopArgs,
          '当前JSSlot参数:',
          this.currentSlotParams,
          '当前解构变量:',
          this.currentDestructuredVars,
        );

        // 优先处理解构变量（需要完全替换为数组访问形式）
        if (isObjectDestructuredVar && destructuredMapping) {
          // 处理计算属性（使用中括号访问）
          if (computed) {
            const propExpr = t.isExpression(property)
              ? this.transformJSExpression(property)
              : property.toString();
            logger(
              `【transformJSExpression】解构变量计算成员表达式: ${destructuredMapping}[${propExpr}]`,
            );
            return `${destructuredMapping}${optional ? '?.' : ''}[${propExpr}]`;
          }

          // 处理普通属性（使用点访问）
          let propStr = '';
          if (t.isIdentifier(property)) {
            propStr = property.name;
          } else if (t.isExpression(property)) {
            propStr = this.transformJSExpression(property);
          } else {
            propStr = property.toString();
          }

          logger(`【transformJSExpression】解构变量成员表达式: ${destructuredMapping}.${propStr}`);
          return `${destructuredMapping}${optional ? '?.' : '.'}${propStr}`;
        }

        // 处理计算属性（使用中括号访问）
        if (computed) {
          // 如果对象是循环变量或JSSlot参数，添加this前缀
          const objStr = isObjectLoopArg || isObjectSlotParam ? `this.${object.name}` : object.name;

          // 处理属性表达式
          const propExpr = t.isExpression(property)
            ? this.transformJSExpression(property)
            : property.toString();
          logger(`【transformJSExpression】处理计算成员表达式: ${objStr}[${propExpr}]`);

          // 检查属性表达式中是否包含循环变量
          let propExprStr = propExpr;
          this.allLoopArgs.forEach((arg) => {
            // 如果属性表达式中直接使用了循环变量（没有this前缀），添加this前缀
            const argPattern = new RegExp(`\\b${arg}\\b(?!\\s*[:=])(?!\\.|\\\")`, 'g');
            if (argPattern.test(propExprStr) && !propExprStr.includes(`this.${arg}`)) {
              logger(`【transformJSExpression】在索引表达式中为循环变量 ${arg} 添加this前缀`);
              propExprStr = propExprStr.replace(argPattern, `this.${arg}`);
            }

            // 特别处理形如 item?.property 或 item.property 的情况
            const argWithPropPattern = new RegExp(
              `\\b${arg}((?:\\?\\.|\\.)[\\w$]+(?:(?:\\?\\.|\\.)[\\w$]+)*)`,
              'g',
            );
            if (argWithPropPattern.test(propExprStr) && !propExprStr.includes(`this.${arg}`)) {
              logger(
                `【transformJSExpression】在索引表达式中为带属性的循环变量 ${arg} 添加this前缀`,
              );
              propExprStr = propExprStr.replace(argWithPropPattern, `this.${arg}$1`);
            }
          });

          // 检查属性表达式中是否包含JSSlot参数
          this.currentSlotParams.forEach((param) => {
            // 如果属性表达式中直接使用了JSSlot参数（没有this前缀），添加this前缀
            const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*[:=])(?!\\.|\\\")`, 'g');
            if (paramPattern.test(propExprStr) && !propExprStr.includes(`this.${param}`)) {
              logger(`【transformJSExpression】在索引表达式中为JSSlot参数 ${param} 添加this前缀`);
              propExprStr = propExprStr.replace(paramPattern, `this.${param}`);
            }

            // 特别处理形如 record?.property 或 record.property 的情况
            const paramWithPropPattern = new RegExp(
              `\\b${param}((?:\\?\\.|\\.)[\\w$]+(?:(?:\\?\\.|\\.)[\\w$]+)*)`,
              'g',
            );
            if (paramWithPropPattern.test(propExprStr) && !propExprStr.includes(`this.${param}`)) {
              logger(
                `【transformJSExpression】在索引表达式中为带属性的JSSlot参数 ${param} 添加this前缀`,
              );
              propExprStr = propExprStr.replace(paramWithPropPattern, `this.${param}$1`);
            }
          });

          return `${objStr}${optional ? '?.' : ''}[${propExprStr}]`;
        }

        // 处理普通属性（使用点访问）
        let propStr = '';
        if (t.isIdentifier(property)) {
          propStr = property.name;
        } else if (t.isExpression(property)) {
          propStr = this.transformJSExpression(property);
        } else {
          propStr = property.toString();
        }

        // 如果是循环参数或JSSlot参数，添加this前缀
        if (isObjectLoopArg || isObjectSlotParam) {
          logger(
            `【transformJSExpression】为循环变量或JSSlot参数成员表达式添加this前缀: this.${object.name}.${propStr}`,
          );
          return `this.${object.name}${optional ? '?.' : '.'}${propStr}`;
        }

        // 如果是state或其他常见对象属性，保持原样
        if (object.name === 'state' || object.name === 'props' || object.name === 'context') {
          logger(`【transformJSExpression】保持常见对象属性原样: ${object.name}.${propStr}`);
          return `${object.name}${optional ? '?.' : '.'}${propStr}`;
        }

        logger(`【transformJSExpression】普通成员表达式: ${object.name}.${propStr}`);
        return `${object.name}${optional ? '?.' : '.'}${propStr}`;
      }

      // 处理其他类型的对象
      const objectStr = this.transformJSExpression(object);

      // 处理计算属性（使用中括号访问）
      if (computed) {
        const propExpr = this.transformJSExpression(property);
        logger(`【transformJSExpression】处理其他类型计算成员表达式: ${objectStr}[${propExpr}]`);

        // 检查属性表达式中是否包含循环变量
        let propExprStr = propExpr;
        this.allLoopArgs.forEach((arg) => {
          // 如果属性表达式中直接使用了循环变量（没有this前缀），添加this前缀
          const argPattern = new RegExp(`\\b${arg}\\b(?!\\s*[:=])`, 'g');
          if (argPattern.test(propExprStr) && !propExprStr.includes(`this.${arg}`)) {
            logger(`【transformJSExpression】在索引表达式中为循环变量 ${arg} 添加this前缀`);
            propExprStr = propExprStr.replace(argPattern, `this.${arg}`);
          }

          // 特别处理形如 item?.property 或 item.property 的情况
          const argWithPropPattern = new RegExp(`\\b${arg}(\\??\\.\\w+)`, 'g');
          if (argWithPropPattern.test(propExprStr) && !propExprStr.includes(`this.${arg}`)) {
            logger(`【transformJSExpression】在索引表达式中为带属性的循环变量 ${arg} 添加this前缀`);
            propExprStr = propExprStr.replace(argWithPropPattern, `this.${arg}$1`);
          }
        });

        // 检查属性表达式中是否包含JSSlot参数
        this.currentSlotParams.forEach((param) => {
          // 如果属性表达式中直接使用了JSSlot参数（没有this前缀），添加this前缀
          const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*[:=])`, 'g');
          if (paramPattern.test(propExprStr) && !propExprStr.includes(`this.${param}`)) {
            logger(`【transformJSExpression】在索引表达式中为JSSlot参数 ${param} 添加this前缀`);
            propExprStr = propExprStr.replace(paramPattern, `this.${param}`);
          }

          // 特别处理形如 record?.property 或 record.property 的情况
          const paramWithPropPattern = new RegExp(
            `\\b${param}((?:\\?\\.|\\.)[\\w$]+(?:(?:\\?\\.|\\.)[\\w$]+)*)`,
            'g',
          );
          if (paramWithPropPattern.test(propExprStr) && !propExprStr.includes(`this.${param}`)) {
            logger(
              `【transformJSExpression】在索引表达式中为带属性的JSSlot参数 ${param} 添加this前缀`,
            );
            propExprStr = propExprStr.replace(paramWithPropPattern, `this.${param}$1`);
          }
        });

        return `${objectStr}${optional ? '?.' : ''}[${propExprStr}]`;
      }

      // 处理普通属性（使用点访问）
      let propStr = '';
      if (t.isIdentifier(property)) {
        propStr = property.name;
      } else if (t.isExpression(property)) {
        propStr = this.transformJSExpression(property);
      } else {
        propStr = property.toString();
      }

      logger(`【transformJSExpression】其他类型成员表达式: ${objectStr}.${propStr}`);
      return `${objectStr}${optional ? '?.' : '.'}${propStr}`;
    }

    if (t.isBinaryExpression(expr)) {
      logger('【transformJSExpression】处理二元表达式:', {
        operator: expr.operator,
        left: expr.left.type,
        right: expr.right.type,
        fullExpr: expr,
      });
      const left = this.transformJSExpression(expr.left);
      const right = this.transformJSExpression(expr.right);

      // 组合二元表达式
      let result = `${left} ${expr.operator} ${right}`;

      // 检查是否包含JSSlot参数
      this.currentSlotParams.forEach((param) => {
        // 匹配独立的JSSlot参数（不是作为对象属性的一部分）
        const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*[:=])`, 'g');
        if (paramPattern.test(result) && !result.includes(`this.${param}`)) {
          logger(`【transformJSExpression】为二元表达式中的JSSlot参数 ${param} 添加this前缀`);
          result = result.replace(paramPattern, `this.${param}`);
        }

        // 特别处理形如 record?.property 或 record.property 的情况
        const paramWithPropPattern = new RegExp(`\\b${param}(\\??\\.\\w+)`, 'g');
        if (paramWithPropPattern.test(result) && !result.includes(`this.${param}`)) {
          logger(`【transformJSExpression】为二元表达式中带属性的JSSlot参数 ${param} 添加this前缀`);

          // 检查是否已经添加了this前缀，避免重复添加
          if (result.includes(`this.${param}?.`) || result.includes(`this.${param}.`)) {
            logger(
              `【transformJSExpression】二元表达式中带属性的JSSlot参数 ${param} 已经有this前缀，跳过`,
            );
          } else {
            result = result.replace(paramWithPropPattern, `this.${param}$1`);
          }
        }
      });

      // 处理感叹号前缀，确保不会重复添加
      result = this.fixExclamationMarks(result);

      logger(`【transformJSExpression】二元表达式结果: ${result}`);
      return result;
    }

    if (t.isConditionalExpression(expr)) {
      logger(`【transformJSExpression】开始处理条件表达式`);
      logger(`【transformJSExpression】条件表达式test类型: ${expr.test.type}`);
      logger(`【transformJSExpression】条件表达式consequent类型: ${expr.consequent.type}`);
      logger(`【transformJSExpression】条件表达式alternate类型: ${expr.alternate.type}`);

      // 检查是否包含JSX，如果包含则不应该在这里处理
      if (this.hasJSXInConditional(expr)) {
        logger(
          '⚠️【transformJSExpression】检测到包含JSX的条件表达式，这不应该在transformJSExpression中处理！',
        );
        logger('⚠️【transformJSExpression】调用堆栈:', new Error().stack);

        // 这种情况不应该发生，如果发生了说明上层逻辑有问题
        // 但为了避免崩溃，我们返回一个占位符
        const { code } = generate(expr);
        logger(`⚠️【transformJSExpression】包含JSX的条件表达式: ${code}`);
        return `/* 包含JSX的条件表达式应该在transformJSXChild中处理: ${code} */`;
      }

      const test = this.transformJSExpression(expr.test);
      logger(`【transformJSExpression】条件表达式test结果: ${test}`);

      const consequent = this.transformJSExpression(expr.consequent);
      logger(`【transformJSExpression】条件表达式consequent结果: ${consequent}`);

      const alternate = this.transformJSExpression(expr.alternate);
      logger(`【transformJSExpression】条件表达式alternate结果: ${alternate}`);

      // 组合条件表达式
      let result = `${test} ? ${consequent} : ${alternate}`;

      // 检查是否包含JSSlot参数
      this.currentSlotParams.forEach((param) => {
        // 匹配独立的JSSlot参数（不是作为对象属性的一部分）
        const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*[:=])`, 'g');
        if (paramPattern.test(result) && !result.includes(`this.${param}`)) {
          logger(`【transformJSExpression】为条件表达式中的JSSlot参数 ${param} 添加this前缀`);
          result = result.replace(paramPattern, `this.${param}`);
        }

        // 特别处理形如 record?.property 或 record.property 的情况
        // 支持链式访问：item?.field.subfield 或 item.a.b.c
        const paramWithPropPattern = new RegExp(`\\b${param}((?:\\?\\.\\w+)+|(?:\\.\\w+)+)`, 'g');
        if (paramWithPropPattern.test(result) && !result.includes(`this.${param}`)) {
          logger(`【transformJSExpression】为条件表达式中带属性的JSSlot参数 ${param} 添加this前缀`);

          // 检查是否已经添加了this前缀，避免重复添加
          if (result.includes(`this.${param}?.`) || result.includes(`this.${param}.`)) {
            logger(
              `【transformJSExpression】条件表达式中带属性的JSSlot参数 ${param} 已经有this前缀，跳过`,
            );
          } else {
            result = result.replace(paramWithPropPattern, `this.${param}$1`);
          }
        }
      });

      // 处理感叹号前缀，确保不会重复添加
      result = this.fixExclamationMarks(result);

      logger(`【transformJSExpression】条件表达式最终结果: ${result}`);
      return result;
    }

    if (t.isLogicalExpression(expr)) {
      logger(`【transformJSExpression】处理逻辑表达式: ${expr.operator}`);
      return this.transformLogicalExpression(expr);
    }

    if (t.isCallExpression(expr)) {
      // 特殊处理立即执行函数表达式 (IIFE)
      if (t.isArrowFunctionExpression(expr.callee) || t.isFunctionExpression(expr.callee)) {
        logger(`【transformJSExpression】处理立即执行函数表达式 (IIFE)`);

        // 处理函数体，确保变量转换正确
        let functionBody: string;
        if (t.isArrowFunctionExpression(expr.callee)) {
          functionBody = this.transformArrowFunctionToNormalFunction(expr.callee);
        } else {
          // 对于普通函数表达式，需要手动处理
          const { code } = generate(expr.callee);
          functionBody = this.transformJSFunctionAddThis(code);
        }

        // 处理函数参数（如果有的话）
        const args = expr.arguments
          .map((arg) => {
            if (t.isExpression(arg)) {
              // 在函数调用参数中，需要特殊处理，避免错误添加this前缀
              return this.transformJSExpressionInFunctionArg(arg);
            }
            return '';
          })
          .filter(Boolean)
          .join(', ');

        return `(${functionBody})(${args})`;
      }

      logger(`【transformJSExpression】处理函数调用表达式`);
      return this.transformCallExpression(expr);
    }

    if (t.isJSXElement(expr)) {
      logger(`【transformJSExpression】处理JSX元素表达式`);
      // 对于在表达式中的JSX元素，我们需要将其转换为JSSlot形式
      const jsxSchema = this.transformJSXElement(expr);
      // 返回一个特殊标记，表示这里应该是JSSlot
      return `__JSX_ELEMENT_${JSON.stringify(jsxSchema)}__`;
    }

    if (t.isUnaryExpression(expr)) {
      logger(`【transformJSExpression】处理一元表达式: ${expr.operator}`);
      const argument = this.transformJSExpression(expr.argument);
      // 对于需要空格的操作符（如 typeof, void, delete 等），在操作符和参数之间加空格
      const needSpace = ['typeof', 'void', 'delete'].includes(expr.operator);
      return needSpace ? `${expr.operator} ${argument}` : `${expr.operator}${argument}`;
    }

    if (t.isOptionalCallExpression(expr)) {
      logger(`【transformJSExpression】处理可选调用表达式`);
      const callee = this.transformJSExpression(expr.callee as t.Expression);
      const args = expr.arguments
        .map((arg) => {
          if (t.isArrowFunctionExpression(arg)) {
            return this.transformArrowFunctionToNormalFunction(arg);
          }
          // 在函数调用参数中，需要特殊处理，避免错误添加this前缀
          return this.transformJSExpressionInFunctionArg(arg as t.Expression);
        })
        .join(', ');
      return `${callee}(${args})`;
    }

    if (t.isTemplateLiteral(expr)) {
      // 处理模板字符串
      const quasis = expr.quasis.map((q) => q.value.cooked);
      const expressions = expr.expressions.map((e) => {
        if (t.isExpression(e)) {
          return this.transformJSExpression(e);
        }
        return ''; // 对于TSType，返回空字符串
      });
      // 拼接成模板字符串
      let result = '';
      for (let i = 0; i < quasis.length; i++) {
        result += quasis[i];
        if (i < expressions.length) {
          result += '${' + expressions[i] + '}';
        }
      }
      return '`' + result + '`';
    }

    if (t.isNewExpression(expr)) {
      // 处理 new 表达式
      const callee = t.isExpression(expr.callee)
        ? this.transformJSExpression(expr.callee)
        : expr.callee.name; // 处理 V8IntrinsicIdentifier
      const args = expr.arguments
        .map((arg) => {
          if (t.isExpression(arg)) {
            // 在函数调用参数中，需要特殊处理，避免错误添加this前缀
            return this.transformJSExpressionInFunctionArg(arg);
          }
          return ''; // 对于ArgumentPlaceholder，返回空字符串
        })
        .filter(Boolean)
        .join(', ');
      return `new ${callee}(${args})`;
    }

    logger(`【transformJSExpression】未处理的表达式类型: ${expr.type}`);
    return '';
  }

  private transformLogicalExpression(expr: t.LogicalExpression): string {
    const left = this.transformJSExpression(expr.left);
    const right = this.transformJSExpression(expr.right);

    // 组合逻辑表达式
    let result = `${left} ${expr.operator} ${right}`;

    // 检查是否包含JSSlot参数
    this.currentSlotParams.forEach((param) => {
      // 匹配独立的JSSlot参数（不是作为对象属性的一部分）
      const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*[:=])`, 'g');
      if (paramPattern.test(result) && !result.includes(`this.${param}`)) {
        logger(`【transformLogicalExpression】为JSSlot参数 ${param} 添加this前缀`);
        result = result.replace(paramPattern, `this.${param}`);
      }

      // 特别处理形如 record?.property 或 record.property 的情况
      const paramWithPropPattern = new RegExp(`\\b${param}(\\??\\.\\w+)`, 'g');
      if (paramWithPropPattern.test(result) && !result.includes(`this.${param}`)) {
        logger(`【transformLogicalExpression】为带属性的JSSlot参数 ${param} 添加this前缀`);

        // 检查是否已经添加了this前缀，避免重复添加
        if (result.includes(`this.${param}?.`) || result.includes(`this.${param}.`)) {
          logger(`【transformLogicalExpression】带属性的JSSlot参数 ${param} 已经有this前缀，跳过`);
        } else {
          result = result.replace(paramWithPropPattern, `this.${param}$1`);
        }
      }
    });

    // 处理感叹号前缀，确保不会重复添加
    result = this.fixExclamationMarks(result);

    return result;
  }

  // 判断表达式是否需要括号保护
  private needsParentheses(expr: t.Expression): boolean {
    // 复杂表达式需要括号保护
    return (
      t.isBinaryExpression(expr) ||
      t.isLogicalExpression(expr) ||
      t.isConditionalExpression(expr) ||
      t.isAssignmentExpression(expr) ||
      t.isSequenceExpression(expr)
    );
  }

  /**
   * 在函数调用参数中转换JS表达式，避免错误添加this前缀
   * @param expr 表达式
   * @returns 转换后的字符串
   */
  private transformJSExpressionInFunctionArg(expr: t.Expression): string {
    // 对于成员表达式，需要特殊处理
    if (t.isMemberExpression(expr) || t.isOptionalMemberExpression(expr)) {
      const object = expr.object;
      const property = expr.property;
      const computed = expr.computed;
      const optional = t.isOptionalMemberExpression(expr);

      // 如果对象是标识符且是循环变量，不要添加this前缀
      if (t.isIdentifier(object)) {
        const isLoopArg = this.allLoopArgs.includes(object.name);
        const isSlotParam = this.currentSlotParams.includes(object.name);

        logger(
          `【transformJSExpressionInFunctionArg】处理成员表达式: ${object.name}, 是否是循环变量: ${isLoopArg}, 是否是JSSlot参数: ${isSlotParam}`,
        );

        // 在函数参数中，循环变量应该添加this前缀
        if (isLoopArg) {
          if (computed) {
            const propExpr = t.isExpression(property)
              ? this.transformJSExpressionInFunctionArg(property)
              : property.toString();
            return `this.${object.name}${optional ? '?.' : ''}[${propExpr}]`;
          } else {
            const propStr = t.isIdentifier(property) ? property.name : property.toString();
            return `this.${object.name}${optional ? '?.' : '.'}${propStr}`;
          }
        }

        // 对于JSSlot参数，也添加this前缀
        if (isSlotParam) {
          if (computed) {
            const propExpr = t.isExpression(property)
              ? this.transformJSExpressionInFunctionArg(property)
              : property.toString();
            return `this.${object.name}${optional ? '?.' : ''}[${propExpr}]`;
          } else {
            const propStr = t.isIdentifier(property) ? property.name : property.toString();
            return `this.${object.name}${optional ? '?.' : '.'}${propStr}`;
          }
        }
      }
    }

    // 对于其他表达式，使用原有的转换逻辑
    return this.transformJSExpression(expr);
  }

  private transformCallExpression(expr: t.CallExpression): string {
    if (t.isMemberExpression(expr.callee) || t.isOptionalMemberExpression(expr.callee)) {
      const object = expr.callee.object;
      const property = t.isIdentifier(expr.callee.property) ? expr.callee.property.name : '';

      // 特别处理this表达式，确保this被保留
      if (t.isThisExpression(object)) {
        const args = expr.arguments
          .map((arg) => {
            if (t.isArrowFunctionExpression(arg)) {
              return this.transformArrowFunctionToNormalFunction(arg);
            }
            if (t.isFunctionExpression(arg)) {
              // 特殊处理普通函数表达式，确保参数不被错误添加this前缀
              return this.transformFunctionExpressionToString(arg);
            }
            if (t.isExpression(arg)) {
              // 在函数调用参数中，需要特殊处理，避免错误添加this前缀
              return this.transformJSExpressionInFunctionArg(arg);
            }
            return ''; // 对于ArgumentPlaceholder，返回空字符串
          })
          .filter(Boolean)
          .join(', ');
        return `this.${property}(${args})`;
      }

      let objectStr = this.transformJSExpression(object);

      // 如果对象是复杂表达式，需要添加括号保护
      if (this.needsParentheses(object)) {
        objectStr = `(${objectStr})`;
        logger(`【transformCallExpression】为复杂对象表达式添加括号: (${objectStr})`);
      }

      const args = expr.arguments
        .map((arg) => {
          if (t.isArrowFunctionExpression(arg)) {
            return this.transformArrowFunctionToNormalFunction(arg);
          }
          if (t.isFunctionExpression(arg)) {
            // 特殊处理普通函数表达式，确保参数不被错误添加this前缀
            return this.transformFunctionExpressionToString(arg);
          }
          if (t.isExpression(arg)) {
            // 在函数调用参数中，需要特殊处理，避免错误添加this前缀
            return this.transformJSExpressionInFunctionArg(arg);
          }
          return ''; // 对于ArgumentPlaceholder，返回空字符串
        })
        .filter(Boolean)
        .join(', ');
      return `${objectStr}.${property}(${args})`;
    }
    if (t.isIdentifier(expr.callee)) {
      const args = expr.arguments
        .map((arg) => {
          if (t.isArrowFunctionExpression(arg)) {
            return this.transformArrowFunctionToNormalFunction(arg);
          }
          if (t.isFunctionExpression(arg)) {
            // 特殊处理普通函数表达式，确保参数不被错误添加this前缀
            return this.transformFunctionExpressionToString(arg);
          }
          if (t.isExpression(arg)) {
            // 在函数调用参数中，需要特殊处理，避免错误添加this前缀
            return this.transformJSExpressionInFunctionArg(arg);
          }
          return ''; // 对于ArgumentPlaceholder，返回空字符串
        })
        .filter(Boolean)
        .join(', ');
      return `${expr.callee.name}(${args})`;
    }
    return '';
  }

  private transformBlockStatement(block: t.BlockStatement): string {
    const statements = block.body
      .map((statement) => {
        if (t.isReturnStatement(statement)) {
          return `return ${
            statement.argument ? this.transformJSExpression(statement.argument) : ''
          }`;
        }
        if (t.isExpressionStatement(statement)) {
          // 确保表达式中的this引用被保留
          const exprStr = this.transformJSExpression(statement.expression);
          return exprStr;
        }
        if (t.isVariableDeclaration(statement)) {
          // 处理变量声明语句
          const declarations = statement.declarations
            .map((declarator) => {
              const id = t.isIdentifier(declarator.id)
                ? declarator.id.name
                : generate(declarator.id).code;
              const init = declarator.init
                ? this.transformJSExpression(declarator.init)
                : 'undefined';
              return `${id} = ${init}`;
            })
            .join(', ');
          return `${statement.kind} ${declarations}`;
        }
        if (t.isIfStatement(statement)) {
          // 处理if语句
          const test = this.transformJSExpression(statement.test);
          const consequent = t.isBlockStatement(statement.consequent)
            ? this.transformBlockStatement(statement.consequent)
            : t.isExpression(statement.consequent)
            ? this.transformJSExpression(statement.consequent)
            : generate(statement.consequent).code;

          let result = `if (${test}) ${consequent}`;

          // 处理else部分
          if (statement.alternate) {
            const alternate = t.isBlockStatement(statement.alternate)
              ? this.transformBlockStatement(statement.alternate)
              : t.isIfStatement(statement.alternate)
              ? generate(statement.alternate).code // 处理else if
              : t.isExpression(statement.alternate)
              ? this.transformJSExpression(statement.alternate)
              : generate(statement.alternate).code;
            result += ` else ${alternate}`;
          }

          return result;
        }
        if (t.isTryStatement(statement)) {
          // 处理try语句
          const tryBlock = this.transformBlockStatement(statement.block);
          let result = `try ${tryBlock}`;

          // 处理catch部分
          if (statement.handler) {
            const param = statement.handler.param
              ? t.isIdentifier(statement.handler.param)
                ? statement.handler.param.name
                : generate(statement.handler.param).code
              : '';
            const catchBlock = this.transformBlockStatement(statement.handler.body);
            result += ` catch${param ? ` (${param})` : ''} ${catchBlock}`;
          }

          // 处理finally部分
          if (statement.finalizer) {
            const finallyBlock = this.transformBlockStatement(statement.finalizer);
            result += ` finally ${finallyBlock}`;
          }

          return result;
        }
        if (t.isForStatement(statement)) {
          // 处理for循环
          const init = statement.init
            ? t.isVariableDeclaration(statement.init)
              ? generate(statement.init).code
              : this.transformJSExpression(statement.init)
            : '';
          const test = statement.test ? this.transformJSExpression(statement.test) : '';
          const update = statement.update ? this.transformJSExpression(statement.update) : '';
          const forBody = t.isBlockStatement(statement.body)
            ? this.transformBlockStatement(statement.body)
            : t.isExpression(statement.body)
            ? this.transformJSExpression(statement.body)
            : generate(statement.body).code;

          return `for (${init}; ${test}; ${update}) ${forBody}`;
        }
        if (t.isWhileStatement(statement)) {
          // 处理while循环
          const test = this.transformJSExpression(statement.test);
          const whileBody = t.isBlockStatement(statement.body)
            ? this.transformBlockStatement(statement.body)
            : t.isExpression(statement.body)
            ? this.transformJSExpression(statement.body)
            : generate(statement.body).code;

          return `while (${test}) ${whileBody}`;
        }
        if (t.isForInStatement(statement) || t.isForOfStatement(statement)) {
          // 处理for...in和for...of循环
          const left = t.isVariableDeclaration(statement.left)
            ? generate(statement.left).code
            : t.isExpression(statement.left)
            ? this.transformJSExpression(statement.left)
            : generate(statement.left).code; // 对于其他LVal类型，使用generate
          const right = this.transformJSExpression(statement.right);
          const forBody = t.isBlockStatement(statement.body)
            ? this.transformBlockStatement(statement.body)
            : t.isExpression(statement.body)
            ? this.transformJSExpression(statement.body)
            : generate(statement.body).code; // 对于其他Statement类型，使用generate
          const forType = t.isForInStatement(statement) ? 'in' : 'of';

          return `for (${left} ${forType} ${right}) ${forBody}`;
        }

        // 对于其他不支持的语句类型，尝试使用generate生成代码
        try {
          logger('使用generate处理语句类型:', statement.type);
          const { code } = generate(statement);
          return code;
        } catch (error) {
          console.error('使用generate处理语句失败:', error);
          logger('不支持的语句类型:', statement.type, statement);
          return `/* 不支持的语句类型: ${statement.type} */`;
        }
      })
      .filter(Boolean);
    return `{ ${statements.join('; ')} }`;
  }

  private transformJSXChild(
    child: t.JSXElement | t.JSXText | t.JSXExpressionContainer | t.JSXFragment | t.JSXSpreadChild,
    parentComponentName?: string,
  ): any {
    logger(
      `【transformJSXChild】开始处理JSX子节点，类型: ${child.type}, 父组件: ${
        parentComponentName || '无'
      }`,
    );

    // 特殊处理Text组件的混合文本模式（文本+表达式）
    if (parentComponentName === 'Text' && t.isJSXText(child)) {
      // 检查下一个兄弟节点是否为JSXExpressionContainer
      const nextSibling = this.getNextSibling(child);
      if (nextSibling && t.isJSXExpressionContainer(nextSibling)) {
        logger(`【transformJSXChild】检测到Text组件中的混合文本模式`);

        // 获取当前文本内容和表达式内容
        const textContent = child.value.trim();
        const exprContent = generate(nextSibling.expression).code;

        // 将文本和表达式组合成一个模板字符串表达式
        const combinedExpr = `\`${textContent}\${${exprContent}}\``;
        logger(`【transformJSXChild】组合后的表达式: ${combinedExpr}`);

        // 标记这个节点已被处理，避免重复处理
        this.markNodeAsProcessed(nextSibling);

        return {
          type: 'JSExpression',
          value: combinedExpr,
        };
      }
    }

    if (t.isJSXText(child)) {
      const text = child.value.trim();
      logger(`【transformJSXChild】处理JSX文本: "${text}"`);
      return text ? text : null;
    }

    if (t.isJSXElement(child)) {
      logger(`【transformJSXChild】处理JSX元素`);
      return this.transformJSXElement(child);
    }

    if (t.isJSXExpressionContainer(child)) {
      const expression = child.expression;
      logger(`【transformJSXChild】处理JSX表达式容器，表达式类型: ${expression.type}`);

      // 检查是否是空表达式（注释），如果是则直接返回null，避免生成空的Text组件
      if (t.isJSXEmptyExpression(expression)) {
        logger(`【transformJSXChild】检测到JSX注释，跳过处理`);
        return null;
      }

      // 特殊处理Text组件的子节点，确保它是JSExpression类型
      if (parentComponentName === 'Text') {
        logger(`【transformJSXChild】特殊处理Text组件的子节点:`, expression);

        // 获取表达式的原始代码
        const { code } = generate(expression);
        logger(`【transformJSXChild】Text组件子节点表达式原始代码: "${code}"`);
        logger(`【transformJSXChild】当前循环变量:`, this.currentLoopArgs);
        logger(`【transformJSXChild】当前JSSlot参数:`, this.currentSlotParams);

        // 处理循环变量引用，确保正确添加this前缀
        let expressionValue = code;

        // 优先处理解构变量（需要完全替换为数组访问形式）
        logger(`【transformJSXChild】当前解构变量:`, this.currentDestructuredVars);
        logger(`【transformJSXChild】解构变量映射:`, this.destructuredVarMappings);

        this.currentDestructuredVars.forEach((varName) => {
          const mapping = this.destructuredVarMappings.get(varName);
          if (mapping) {
            // 处理成员表达式，如 type.color -> this.entry[1].color
            const memberPattern = new RegExp(
              `\\b${varName}((?:\\?\\.|\\.)[\\w$]+(?:(?:\\?\\.|\\.)[\\w$]+)*)`,
              'g',
            );
            if (memberPattern.test(expressionValue)) {
              logger(`【transformJSXChild】替换解构变量成员表达式 ${varName} 为 ${mapping}`);
              expressionValue = expressionValue.replace(memberPattern, `${mapping}$1`);
            }

            // 处理独立的解构变量，如 type -> this.entry[1]
            const varPattern = new RegExp(
              `\\b${varName}\\b(?![\\w$])(?!\\s*\\?\\s*\\.)(?!\\s*\\.)(?!\\s*\\[)`,
              'g',
            );
            if (varPattern.test(expressionValue)) {
              logger(`【transformJSXChild】替换解构变量 ${varName} 为 ${mapping}`);
              expressionValue = expressionValue.replace(varPattern, mapping);
            }
          }
        });

        // 先检查是否已经有重复的this前缀，如this.this.item，将其修正为this.item
        const thisRepeatPattern1 = /this\.this\./g;
        if (thisRepeatPattern1.test(expressionValue)) {
          logger(`【transformJSXChild】修复重复的this前缀`);
          expressionValue = expressionValue.replace(thisRepeatPattern1, 'this.');
        }

        // 检查当前循环变量和所有循环变量
        logger(`【transformJSXChild】当前循环变量:`, this.currentLoopArgs);
        logger(`【transformJSXChild】所有循环变量:`, this.allLoopArgs);

        // 替换形如 this.item 的引用为 item（临时替换，后面会再添加this前缀）
        this.allLoopArgs.forEach((arg) => {
          const thisPattern = new RegExp(`this\\.${arg}\\b`, 'g');
          if (thisPattern.test(expressionValue)) {
            logger(`【transformJSXChild】替换 this.${arg} 为 ${arg}`);
            expressionValue = expressionValue.replace(thisPattern, arg);
          }
        });

        // 处理JSSlot参数，移除已有的this前缀（如果有）
        this.currentSlotParams.forEach((param) => {
          const thisPattern = new RegExp(`this\\.${param}\\b`, 'g');
          if (thisPattern.test(expressionValue)) {
            logger(`【transformJSXChild】替换 this.${param} 为 ${param}`);
            expressionValue = expressionValue.replace(thisPattern, param);
          }
        });

        // 现在为所有循环变量添加this前缀
        this.allLoopArgs.forEach((arg) => {
          // 特别处理形如 item?.property 或 item.property 的情况
          const argWithPropPattern = new RegExp(
            `\\b${arg}((?:\\??\\.|\\.)[\\w$]+(?:\\??\\.|\\.)?[\\w$]*)`,
            'g',
          );
          logger('argWithPropPattern: ', argWithPropPattern, expressionValue);

          // 检查是否包含带属性的参数引用，但不使用test()方法避免影响replace()
          const hasArgWithProp = expressionValue.match(argWithPropPattern);
          if (hasArgWithProp) {
            logger(`【transformJSXChild】为带属性的循环变量 ${arg} 添加this前缀`);

            // 重新创建正则表达式，避免lastIndex问题
            const freshArgWithPropPattern = new RegExp(
              `\\b${arg}((?:\\??\\.|\\.)[\\w$]+(?:\\??\\.|\\.)?[\\w$]*)`,
              'g',
            );
            expressionValue = expressionValue.replace(freshArgWithPropPattern, (match, p1) => {
              // 检查这个匹配是否已经有this前缀
              if (match.startsWith(`this.${arg}`)) {
                return match; // 已经有this前缀，保持不变
              }
              logger(
                `【transformJSXChild】为带属性的循环变量 ${arg} 添加this前缀: ${match} -> this.${arg}${p1}`,
              );
              return `this.${arg}${p1}`;
            });
          }

          // 特别处理数组访问的情况，如 entry[0], entry[1] 等
          const argWithArrayPattern = new RegExp(`\\b${arg}\\[([^\\]]+)\\]`, 'g');
          const hasArgWithArray = expressionValue.match(argWithArrayPattern);
          if (hasArgWithArray) {
            logger(`【transformJSXChild】为数组访问的循环变量 ${arg} 添加this前缀`);

            // 重新创建正则表达式，避免lastIndex问题
            const freshArgWithArrayPattern = new RegExp(`\\b${arg}\\[([^\\]]+)\\]`, 'g');
            expressionValue = expressionValue.replace(
              freshArgWithArrayPattern,
              (match, index, offset, str) => {
                // 检查前面是否已经有this前缀
                const beforeMatch = str.substring(Math.max(0, offset - 5), offset);
                if (beforeMatch.endsWith('this.')) {
                  return match; // 已经有this前缀，保持不变
                }
                logger(
                  `【transformJSXChild】为数组访问的循环变量 ${arg} 添加this前缀: ${match} -> this.${arg}[${index}]`,
                );
                return `this.${arg}[${index}]`;
              },
            );
          }

          // 处理独立的循环变量，包括比较操作符的情况
          // 注意：这里不再排除数组访问，因为上面已经单独处理了
          const argPattern = new RegExp(
            `\\b${arg}\\b(?![\\w$])(?!\\s*\\?\\s*\\.)(?!\\s*\\.)(?!\\s*\\[)(?!\\s*\\(\\s*\\{)`,
            'g',
          );

          // 直接进行全局替换，处理独立的循环变量
          expressionValue = expressionValue.replace(argPattern, (match, offset, str) => {
            // 检查前面是否已经有this前缀或者是成员表达式的一部分
            const beforeMatch = str.substring(Math.max(0, offset - 10), offset);

            // 如果前面有 this. 前缀，跳过
            if (beforeMatch.includes(`this.${arg}`) || beforeMatch.endsWith('this.')) {
              logger(`【transformJSXChild】${arg} 已经有this前缀，跳过: ${beforeMatch}${match}`);
              return match; // 已经有this前缀，保持不变
            }

            // 如果前面有点号，说明是成员表达式的一部分，也跳过
            if (beforeMatch.endsWith('.')) {
              logger(
                `【transformJSXChild】${arg} 是成员表达式的一部分，跳过: ${beforeMatch}${match}`,
              );
              return match; // 是成员表达式的一部分，保持不变
            }

            logger(
              `【transformJSXChild】为独立循环变量 ${arg} 添加this前缀: ${match} -> this.${arg}`,
            );
            return `this.${arg}`;
          });
        });

        // 为所有JSSlot参数添加this前缀
        this.currentSlotParams.forEach((param) => {
          // 匹配独立的JSSlot参数（不是作为对象属性的一部分）
          const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*=)(?!\\.|\\\")`, 'g');
          expressionValue = expressionValue.replace(paramPattern, (match, offset, str) => {
            // 使用安全检查
            if (this.shouldAddThisPrefix(str, param, offset)) {
              logger(`【transformJSXChild】为JSSlot参数 ${param} 添加this前缀`);
              return `this.${param}`;
            } else {
              return match; // 保持原样
            }
          });

          // 特别处理形如 record?.property 或 record.property 的情况
          const paramWithPropPattern = new RegExp(
            `\\b${param}((?:\\?\.|\.)[\\w$]+(?:(?:\\?\.|\.)[\\w$]+)*)`,
            'g',
          );
          expressionValue = expressionValue.replace(
            paramWithPropPattern,
            (match, prop, offset, str) => {
              // 使用安全检查
              if (this.shouldAddThisPrefix(str, param, offset)) {
                logger(`【transformJSXChild】为带属性的JSSlot参数 ${param} 添加this前缀`);
                return `this.${param}${prop}`;
              } else {
                return match; // 保持原样
              }
            },
          );
        });

        // 处理感叹号前缀，确保不会重复添加
        expressionValue = this.fixExclamationMarks(expressionValue);

        // 最后检查是否有重复的this前缀，如this.this.item，将其修正为this.item
        const thisRepeatPattern2 = /this\.this\./g;
        if (thisRepeatPattern2.test(expressionValue)) {
          logger(`【transformJSXChild】修复重复的this前缀`);
          expressionValue = expressionValue.replace(thisRepeatPattern2, 'this.');
        }

        logger(`【transformJSXChild】处理后的表达式值: "${expressionValue}"`);

        const result = {
          type: 'JSExpression',
          value: expressionValue,
        };
        logger(`【transformJSXChild】Text组件子节点最终结果:`, result.value);
        return result;
      }

      if (t.isLogicalExpression(expression)) {
        // 处理逻辑表达式作为条件渲染
        let result;
        if (t.isJSXElement(expression.right)) {
          result = this.transformJSXElement(expression.right);
        } else if (
          (t.isCallExpression(expression.right) || t.isOptionalCallExpression(expression.right)) &&
          (t.isMemberExpression(expression.right.callee) ||
            t.isOptionalMemberExpression(expression.right.callee)) &&
          t.isIdentifier(expression.right.callee.property) &&
          expression.right.callee.property.name === 'map'
        ) {
          // 这是一个循环渲染
          const arrayExpr = expression.right.callee.object;
          const mapCallback = expression.right.arguments[0];

          if (t.isArrowFunctionExpression(mapCallback)) {
            const params = mapCallback.params;
            const body = mapCallback.body;

            // 保存之前的循环参数
            const prevLoopArgs = [...this.currentLoopArgs];

            // 获取循环变量名
            const itemParam = params[0];
            const indexParam = params[1];
            const itemName = t.isIdentifier(itemParam) ? itemParam.name : 'item';
            const indexName = t.isIdentifier(indexParam) ? indexParam.name : 'index';

            logger(
              `【transformJSXChild】逻辑表达式中的循环变量: itemName=${itemName}, indexName=${indexName}`,
            );
            logger(`【transformJSXChild】逻辑表达式中之前的循环变量:`, prevLoopArgs);

            // 更新当前循环参数 - 保持嵌套循环的所有变量
            this.currentLoopArgs = [...prevLoopArgs, itemName, indexName];

            // 将新的循环变量添加到所有循环变量列表中
            if (!this.allLoopArgs.includes(itemName)) {
              this.allLoopArgs.push(itemName);
            }
            if (!this.allLoopArgs.includes(indexName)) {
              this.allLoopArgs.push(indexName);
            }

            try {
              if (t.isJSXElement(body)) {
                result = this.transformJSXElement(body);
                result.loop = {
                  type: 'JSExpression',
                  value: this.transformJSExpression(arrayExpr),
                };
                result.loopArgs = [itemName, indexName];
              } else {
                result = {
                  type: 'JSExpression',
                  value: this.transformJSExpression(expression.right),
                };
              }
            } finally {
              // 恢复之前的循环参数
              this.currentLoopArgs = prevLoopArgs;
            }
          } else {
            result = {
              type: 'JSExpression',
              value: this.transformJSExpression(expression.right),
            };
          }
        } else {
          result = {
            type: 'JSExpression',
            value: this.transformJSExpression(expression.right),
          };
        }

        // 将左侧的表达式作为条件，右侧的 JSX 作为节点内容
        const { code } = generate(expression.left);
        let conditionValue = code;

        // 先处理JSSlot参数
        this.currentSlotParams.forEach((param) => {
          // 匹配独立的JSSlot参数（不是作为对象属性的一部分）
          const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*[:=])`, 'g');
          if (paramPattern.test(conditionValue)) {
            logger(`【transformJSXChild】为条件表达式中的JSSlot参数 ${param} 添加this前缀`);
            conditionValue = conditionValue.replace(paramPattern, `this.${param}`);
          }

          // 特别处理形如 item?.property 或 item.property 的情况
          // 支持链式访问：item?.field.subfield 或 item.a.b.c
          const paramWithPropPattern = new RegExp(`\\b${param}((?:\\?\\.\\w+)+|(?:\\.\\w+)+)`, 'g');
          if (paramWithPropPattern.test(conditionValue)) {
            logger(`【transformJSXChild】为条件表达式中带属性的JSSlot参数 ${param} 添加this前缀`);

            // 直接进行全局替换，但要避免重复添加this前缀
            const paramWithPropPattern = new RegExp(
              `\\b${param}((?:\\?\\.\\w+)+|(?:\\.\\w+)+)`,
              'g',
            );
            conditionValue = conditionValue.replace(paramWithPropPattern, (match, p1) => {
              // 检查这个匹配是否已经有this前缀
              if (match.startsWith(`this.${param}`)) {
                return match; // 已经有this前缀，保持不变
              }
              logger(
                `【transformJSXChild】为条件表达式中带属性的JSSlot参数 ${param} 添加this前缀: ${match} -> this.${param}${p1}`,
              );
              return `this.${param}${p1}`;
            });
          }
        });

        // 处理感叹号前缀，确保不会重复添加
        conditionValue = this.fixExclamationMarks(conditionValue);

        // 处理循环变量引用，确保正确添加this前缀
        // 先检查是否已经有重复的this前缀，如this.this.item，将其修正为this.item
        const thisRepeatPattern1 = /this\.this\./g;
        if (thisRepeatPattern1.test(conditionValue)) {
          logger(`【transformJSXChild】修复重复的this前缀`);
          conditionValue = conditionValue.replace(thisRepeatPattern1, 'this.');
        }

        // 检查当前循环变量和所有循环变量
        logger(`【transformJSXChild】当前循环变量:`, this.currentLoopArgs);
        logger(`【transformJSXChild】所有循环变量:`, this.allLoopArgs);

        // 替换形如 this.item 的引用为 item（临时替换，后面会再添加this前缀）
        this.allLoopArgs.forEach((arg) => {
          const thisPattern = new RegExp(`this\\.${arg}\\b`, 'g');
          if (thisPattern.test(conditionValue)) {
            logger(`【transformJSXChild】替换 this.${arg} 为 ${arg}`);
            conditionValue = conditionValue.replace(thisPattern, arg);
          }
        });

        // 处理JSSlot参数，移除已有的this前缀（如果有）
        this.currentSlotParams.forEach((param) => {
          const thisPattern = new RegExp(`this\\.${param}\\b`, 'g');
          if (thisPattern.test(conditionValue)) {
            logger(`【transformJSXChild】替换 this.${param} 为 ${param}`);
            conditionValue = conditionValue.replace(thisPattern, param);
          }
        });
        logger('conditionValue: ', conditionValue);
        logger('this.allLoopArgs: ', this.allLoopArgs);
        // 现在为所有循环变量添加this前缀
        this.allLoopArgs.forEach((arg) => {
          logger('conditionValue: ', conditionValue, arg);
          // 先处理带属性的循环变量
          const argWithPropPattern = new RegExp(`\\b${arg}(\\??\\.|\\.)([\\w$]+)`, 'g');
          if (argWithPropPattern.test(conditionValue)) {
            logger('conditionValue: ', conditionValue, arg);
            logger(`【transformJSXChild】为带属性的循环变量 ${arg} 添加this前缀`);

            // 直接进行全局替换，但要避免重复添加this前缀
            conditionValue = conditionValue.replace(
              new RegExp(`\\b${arg}(?:\\??\\.|\\.)(\\w+)`, 'g'),
              (match, p1) => {
                // 检查这个匹配是否已经有this前缀
                if (match.startsWith(`this.${arg}`)) {
                  return match; // 已经有this前缀，保持不变
                }
                logger(
                  `【transformJSXChild】为带属性的循环变量 ${arg} 添加this前缀: ${match} -> this.${arg}?.${p1}`,
                );
                return `this.${arg}?.${p1}`;
              },
            );
          }

          // 处理数组访问的情况，如 entry[0], entry[1] 等
          const argWithArrayPattern = new RegExp(`\\b${arg}\\[([^\\]]+)\\]`, 'g');
          if (argWithArrayPattern.test(conditionValue)) {
            logger(`【transformJSXChild】为条件表达式中数组访问的循环变量 ${arg} 添加this前缀`);

            // 重新创建正则表达式，避免lastIndex问题
            const freshArgWithArrayPattern = new RegExp(`\\b${arg}\\[([^\\]]+)\\]`, 'g');
            conditionValue = conditionValue.replace(
              freshArgWithArrayPattern,
              (match, index, offset, str) => {
                // 检查前面是否已经有this前缀
                const beforeMatch = str.substring(Math.max(0, offset - 5), offset);
                if (beforeMatch.endsWith('this.')) {
                  return match; // 已经有this前缀，保持不变
                }
                logger(
                  `【transformJSXChild】为条件表达式中数组访问的循环变量 ${arg} 添加this前缀: ${match} -> this.${arg}[${index}]`,
                );
                return `this.${arg}[${index}]`;
              },
            );
          }

          // 再处理独立的循环变量
          const argPattern = new RegExp(`\\b${arg}\\b(?!\\s*=[^=])(?!\\.|\\")(?!\\[)`, 'g');
          logger(
            `【DEBUG】处理循环变量 ${arg}，正则: ${argPattern}，当前conditionValue: "${conditionValue}"`,
          );
          logger(`【DEBUG】正则测试结果: ${argPattern.test(conditionValue)}`);
          // 重置lastIndex
          argPattern.lastIndex = 0;
          // 直接进行全局替换，处理独立的循环变量
          const originalConditionValue = conditionValue;
          conditionValue = conditionValue.replace(argPattern, (match, offset, str) => {
            logger(`【DEBUG】匹配到: "${match}", offset: ${offset}`);
            // 检查前面是否已经有this前缀
            const beforeMatch = str.substring(Math.max(0, offset - 5), offset);
            logger(`【DEBUG】前面的字符: "${beforeMatch}"`);
            if (beforeMatch.endsWith('this.')) {
              logger(`【DEBUG】已有this前缀，跳过`);
              return match; // 已经有this前缀，保持不变
            }
            logger(
              `【transformJSXChild】为独立循环变量 ${arg} 添加this前缀: ${match} -> this.${arg}`,
            );
            return `this.${arg}`;
          });
          logger(
            `【DEBUG】处理${arg}后，conditionValue从 "${originalConditionValue}" 变为 "${conditionValue}"`,
          );
        });

        // 为所有JSSlot参数添加this前缀
        this.currentSlotParams.forEach((param) => {
          // 匹配独立的JSSlot参数（不是作为对象属性的一部分）
          const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*=[^=])(?!\\.|\\\")`, 'g');
          conditionValue = conditionValue.replace(paramPattern, (match, offset, str) => {
            // 使用安全检查
            if (this.shouldAddThisPrefix(str, param, offset)) {
              logger(
                `【transformJSXChild】为JSSlot参数 ${param} 添加this前缀: ${match} -> this.${param}`,
              );
              return `this.${param}`;
            } else {
              return match; // 保持原样
            }
          });

          // 特别处理形如 record?.property 或 record.property 的情况
          const paramWithPropPattern = new RegExp(`\\b${param}(\\??\\.\\w+)`, 'g');
          conditionValue = conditionValue.replace(
            paramWithPropPattern,
            (match, p1, offset, str) => {
              // 使用安全检查
              if (this.shouldAddThisPrefix(str, param, offset)) {
                logger(
                  `【transformJSXChild】为带属性的JSSlot参数 ${param} 添加this前缀: ${match} -> this.${param}${p1}`,
                );
                return `this.${param}${p1}`;
              } else {
                return match; // 保持原样
              }
            },
          );
        });

        // 处理感叹号前缀，确保不会重复添加
        conditionValue = this.fixExclamationMarks(conditionValue);

        // 最后检查是否有重复的this前缀，如this.this.item，将其修正为this.item
        const thisRepeatPattern2 = /this\.this\./g;
        if (thisRepeatPattern2.test(conditionValue)) {
          logger(`【transformJSXChild】修复重复的this前缀`);
          conditionValue = conditionValue.replace(thisRepeatPattern2, 'this.');
        }

        logger('【transformJSXChild】处理后的条件表达式:', conditionValue);
        result.condition = {
          type: 'JSExpression',
          value: conditionValue,
        };
        logger('【transformJSXChild】条件表达式最终结果:', result.condition);

        return result;
      }

      if (t.isConditionalExpression(expression)) {
        logger(`【transformJSXChild】处理条件表达式`);

        // 检查条件表达式中是否包含 JSX 元素
        if (this.hasJSXInConditional(expression)) {
          logger(`【transformJSXChild】条件表达式包含JSX，拆分为两个独立的条件渲染`);

          // 获取条件表达式，确保test部分不包含JSX（test部分通常是布尔表达式）
          let test: string;
          if (this.hasJSXInExpression(expression.test)) {
            logger(`【transformJSXChild】警告：条件表达式的test部分包含JSX，使用原始代码`);
            const { code } = generate(expression.test);
            test = code;
          } else {
            test = this.transformJSExpression(expression.test);
          }

          // 创建条件渲染节点的辅助函数
          const createConditionalNode = (expr: t.Expression, conditionValue: string) => {
            logger('🔍【createConditionalNode】=== 开始处理 ===');
            logger(`🔍【createConditionalNode】表达式类型: ${expr.type}`);
            logger(`🔍【createConditionalNode】表达式详情:`, expr);
            logger(`🔍【createConditionalNode】是否为JSXElement: ${t.isJSXElement(expr)}`);
            logger(`🔍【createConditionalNode】是否为StringLiteral: ${t.isStringLiteral(expr)}`);
            logger(`🔍【createConditionalNode】条件值: ${conditionValue}`);

            if (t.isConditionalExpression(expr)) {
              // 如果传入的是条件表达式，说明有嵌套的条件表达式
              logger('🚨【createConditionalNode】接收到嵌套的条件表达式！');
              logger('🚨【createConditionalNode】将递归处理嵌套的条件表达式');

              // 递归处理嵌套的条件表达式
              const nestedTest = this.transformJSExpression(expr.test);
              const nestedConsequent = createConditionalNode(expr.consequent, nestedTest);
              const nestedAlternate = createConditionalNode(expr.alternate, `!(${nestedTest})`);

              // 返回一个包含嵌套条件的容器
              return {
                componentName: 'Fragment', // 使用 Fragment 作为容器
                props: {},
                children: [nestedConsequent, nestedAlternate],
                condition: {
                  type: 'JSExpression',
                  value: conditionValue,
                },
              };
            } else if (t.isStringLiteral(expr)) {
              // 对于字符串字面量，包装成Text组件
              logger(`【createConditionalNode】处理字符串字面量: ${expr.value}`);
              return {
                componentName: 'Text',
                props: {
                  children: expr.value,
                },
                children: [],
                condition: {
                  type: 'JSExpression',
                  value: conditionValue,
                },
              };
            } else if (t.isJSXElement(expr)) {
              // 对于JSX元素，直接转换为组件schema并添加条件
              logger(
                `【createConditionalNode】处理JSX元素，组件名: ${
                  expr.openingElement.name.type === 'JSXIdentifier'
                    ? expr.openingElement.name.name
                    : '复杂组件名'
                }`,
              );
              const jsxSchema = this.transformJSXElement(expr);
              jsxSchema.condition = {
                type: 'JSExpression',
                value: conditionValue,
              };
              return jsxSchema;
            } else {
              // 对于其他表达式，包装成Text组件并使用JSExpression
              logger(`【createConditionalNode】处理其他表达式类型: ${expr.type}，将包装为Text组件`);
              const transformedValue = this.transformJSExpression(expr);
              logger(`【createConditionalNode】转换后的表达式值: ${transformedValue}`);
              return {
                componentName: 'Text',
                props: {
                  children: {
                    type: 'JSExpression',
                    value: transformedValue,
                  },
                },
                children: [],
                condition: {
                  type: 'JSExpression',
                  value: conditionValue,
                },
              };
            }
          };

          // 直接返回两个条件渲染节点的数组，不包装在容器中
          logger('🔧【transformJSXChild】准备调用 createConditionalNode');
          logger('🔧【transformJSXChild】consequent 类型:', expression.consequent.type);
          logger('🔧【transformJSXChild】alternate 类型:', expression.alternate.type);
          logger('🔧【transformJSXChild】test 值:', test);

          const result = [
            createConditionalNode(expression.consequent, test),
            createConditionalNode(expression.alternate, `!(${test})`),
          ];

          logger(`【transformJSXChild】条件表达式拆分结果:`, result);
          return result;
        } else {
          logger(`【transformJSXChild】条件表达式为纯文本，转换为JSExpression`);

          // 纯文本条件表达式，直接转换为 JSExpression
          const result = {
            type: 'JSExpression',
            value: this.transformJSExpression(expression),
          };

          logger(`【transformJSXChild】纯文本条件表达式结果:`, result);
          return result;
        }
      }

      // 处理数组遍历表达式
      logger(`【transformJSXChild】检查是否为map循环表达式:`);
      logger(`【transformJSXChild】表达式类型: ${expression.type}`);
      logger(`【transformJSXChild】isCallExpression: ${t.isCallExpression(expression)}`);
      logger(
        `【transformJSXChild】isOptionalCallExpression: ${t.isOptionalCallExpression(expression)}`,
      );

      if (
        (t.isCallExpression(expression) || t.isOptionalCallExpression(expression)) &&
        expression.callee
      ) {
        logger(`【transformJSXChild】callee.type: ${expression.callee.type}`);
        logger(
          `【transformJSXChild】isMemberExpression: ${t.isMemberExpression(expression.callee)}`,
        );
        logger(
          `【transformJSXChild】isOptionalMemberExpression: ${t.isOptionalMemberExpression(
            expression.callee,
          )}`,
        );
      }

      if (
        (t.isCallExpression(expression) || t.isOptionalCallExpression(expression)) &&
        expression.callee &&
        (t.isMemberExpression(expression.callee) ||
          t.isOptionalMemberExpression(expression.callee)) &&
        expression.callee.property &&
        t.isIdentifier(expression.callee.property) &&
        expression.callee.property.name === 'map'
      ) {
        logger(`【transformJSXChild】条件检查通过:`);
        logger(`【transformJSXChild】callee.type: ${expression.callee.type}`);
        logger(`【transformJSXChild】property.name: ${expression.callee.property.name}`);
        logger(`【transformJSXChild】处理map循环表达式`);
        const arrayExpr = expression.callee.object;
        const mapCallback = expression.arguments[0];

        let actualArrayExpr = arrayExpr;
        if (
          t.isCallExpression(arrayExpr) &&
          t.isIdentifier(arrayExpr.callee) &&
          arrayExpr.callee.name === '__$$evalArray'
        ) {
          const evalArrayArg = arrayExpr.arguments[0];
          if (t.isArrowFunctionExpression(evalArrayArg)) {
            if (t.isExpression(evalArrayArg.body)) {
              actualArrayExpr = evalArrayArg.body;
            } else {
              // 如果是BlockStatement，我们需要找到return语句
              const returnStmt = evalArrayArg.body.body.find((stmt) => t.isReturnStatement(stmt));
              if (returnStmt && t.isReturnStatement(returnStmt) && returnStmt.argument) {
                actualArrayExpr = returnStmt.argument;
              }
            }
          }
        }

        if (
          t.isArrowFunctionExpression(mapCallback) ||
          t.isFunctionExpression(mapCallback) ||
          (t.isCallExpression(mapCallback) &&
            t.isMemberExpression(mapCallback.callee) &&
            t.isIdentifier(mapCallback.callee.property) &&
            mapCallback.callee.property.name === 'bind')
        ) {
          // 如果是 .bind() 调用，提取原始函数
          let actualCallback: any = mapCallback;
          if (t.isCallExpression(mapCallback) && t.isMemberExpression(mapCallback.callee)) {
            actualCallback = mapCallback.callee.object;
            logger(`【transformJSXChild】检测到bind调用，提取原始函数:`, actualCallback.type);
          }

          // 确保提取的函数是支持的类型
          if (
            !t.isArrowFunctionExpression(actualCallback) &&
            !t.isFunctionExpression(actualCallback)
          ) {
            logger(`【transformJSXChild】不支持的map回调函数类型:`, actualCallback.type);
            return null;
          }
          const itemParam = actualCallback.params[0];
          const indexParam = actualCallback.params[1];

          // 保存之前的循环参数和解构变量状态
          const prevLoopArgs = [...this.currentLoopArgs];
          const prevDestructuredVars = [...this.currentDestructuredVars];
          const prevMappings = new Map(this.destructuredVarMappings);

          // 检查是否有数组解构参数
          let itemName: string;
          let indexName: string;
          let destructuredVars: string[] = [];

          if (t.isArrayPattern(itemParam)) {
            // 处理数组解构参数，如 ([key, value]) => ...
            itemName = 'entry'; // 使用统一的参数名
            indexName = t.isIdentifier(indexParam) ? indexParam.name : 'index';

            // 提取解构的变量名
            itemParam.elements.forEach((element, index) => {
              if (t.isIdentifier(element)) {
                destructuredVars.push(element.name);
                // 建立解构变量到数组访问的映射
                const mapping = `this.${itemName}[${index}]`;
                this.destructuredVarMappings.set(element.name, mapping);
                this.currentDestructuredVars.push(element.name);
                if (!this.allDestructuredVars.includes(element.name)) {
                  this.allDestructuredVars.push(element.name);
                }
                logger(`【transformJSXChild】添加解构变量映射: ${element.name} -> ${mapping}`);
              }
            });
          } else {
            // 普通参数
            itemName = t.isIdentifier(itemParam) ? itemParam.name : 'item';
            indexName = t.isIdentifier(indexParam) ? indexParam.name : 'index';
          }

          logger(`【transformJSXChild】循环变量: itemName=${itemName}, indexName=${indexName}`);
          logger(`【transformJSXChild】解构变量:`, destructuredVars);
          logger(`【transformJSXChild】之前的循环变量:`, prevLoopArgs);

          // 更新当前循环参数 - 保持嵌套循环的所有变量
          this.currentLoopArgs = [...prevLoopArgs, itemName, indexName];

          // 将新的循环变量添加到所有循环变量列表中
          if (!this.allLoopArgs.includes(itemName)) {
            this.allLoopArgs.push(itemName);
          }
          if (!this.allLoopArgs.includes(indexName)) {
            this.allLoopArgs.push(indexName);
          }

          // 在处理完当前循环后恢复之前的循环参数和解构变量状态
          const cleanup = () => {
            logger(`【transformJSXChild】恢复之前的循环变量:`, prevLoopArgs);
            logger(`【transformJSXChild】恢复之前的解构变量:`, prevDestructuredVars);
            this.currentLoopArgs = prevLoopArgs;
            this.currentDestructuredVars = prevDestructuredVars;
            this.destructuredVarMappings = prevMappings;
            // 注意：我们不从 allLoopArgs 中移除变量，因为它们可能在后续的嵌套表达式中被引用
          };

          // 获取遍历项的 JSX 结构
          const jsxBody = t.isBlockStatement(actualCallback.body)
            ? actualCallback.body.body.find((node) => t.isReturnStatement(node))?.argument
            : actualCallback.body;

          // 创建一个基础的容器节点
          const containerSchema = {
            componentName: 'View',
            props: {},
            children: [],
            loop: {
              type: 'JSExpression',
              value: '',
            },
            loopArgs: [itemName, indexName],
          };

          // 获取循环数组表达式的原始代码
          try {
            const { code } = generate(actualArrayExpr);
            logger(`【transformJSXChild】循环数组表达式原始代码: "${code}"`);

            // 处理循环数组表达式中的循环变量引用
            let arrayExprValue = code;

            // 检查当前循环变量和父级循环变量
            const allLoopArgs = [...this.allLoopArgs];
            logger(
              `【transformJSXChild】处理循环数组表达式中的循环变量引用，所有循环变量:`,
              allLoopArgs,
            );

            // 先检查是否已经有重复的this前缀
            const doubleThisPattern = /this\.this\./g;
            if (doubleThisPattern.test(arrayExprValue)) {
              logger(`【transformJSXChild】修复循环数组表达式中重复的this前缀`);
              arrayExprValue = arrayExprValue.replace(doubleThisPattern, 'this.');
            }

            // 处理 JSSlot 参数
            this.currentSlotParams.forEach((param) => {
              // 匹配独立的 JSSlot 参数（不是作为对象属性的一部分）
              const paramPattern = new RegExp(`\\b${param}\\b(?!\\s*[:=])`, 'g');
              if (paramPattern.test(arrayExprValue) && !arrayExprValue.includes(`this.${param}`)) {
                logger(
                  `【transformJSXChild】为循环数组表达式中的 JSSlot 参数 ${param} 添加this前缀`,
                );
                arrayExprValue = arrayExprValue.replace(paramPattern, `this.${param}`);
              }

              // 特别处理形如 record?.property 或 record.property 的情况
              const paramWithPropPattern = new RegExp(`\\b${param}(\\??\\.\\w+)`, 'g');
              if (
                paramWithPropPattern.test(arrayExprValue) &&
                !arrayExprValue.includes(`this.${param}`)
              ) {
                logger(
                  `【transformJSXChild】为循环数组表达式中带属性的 JSSlot 参数 ${param} 添加this前缀`,
                );
                arrayExprValue = arrayExprValue.replace(paramWithPropPattern, `this.${param}$1`);
              }
            });

            // 处理父级循环变量引用
            allLoopArgs.forEach((arg) => {
              // 匹配独立的循环变量（不是作为对象属性的一部分）
              const argPattern = new RegExp(`\\b${arg}\\b(?!\\s*[:=])`, 'g');
              if (argPattern.test(arrayExprValue) && !arrayExprValue.includes(`this.${arg}`)) {
                logger(`【transformJSXChild】为循环数组表达式中的循环变量 ${arg} 添加this前缀`);
                arrayExprValue = arrayExprValue.replace(argPattern, `this.${arg}`);
              }

              // 特别处理形如 item1?.property 或 item1.property 的情况
              const argWithPropPattern = new RegExp(`\\b${arg}(\\??\\.\\w+)`, 'g');
              if (
                argWithPropPattern.test(arrayExprValue) &&
                !arrayExprValue.includes(`this.${arg}`)
              ) {
                logger(
                  `【transformJSXChild】为循环数组表达式中带属性的循环变量 ${arg} 添加this前缀`,
                );
                arrayExprValue = arrayExprValue.replace(argWithPropPattern, `this.${arg}$1`);
              }
            });

            // 处理普通的状态变量引用（如 state.xxx, props.xxx 等）
            // 使用 transformJSFunctionAddThis 来处理所有可能需要 this 前缀的变量
            arrayExprValue = this.transformJSFunctionAddThis(arrayExprValue);
            logger(
              `【transformJSXChild】使用transformJSFunctionAddThis处理后的数组表达式: "${arrayExprValue}"`,
            );

            // 处理感叹号前缀
            arrayExprValue = this.fixExclamationMarks(arrayExprValue);

            containerSchema.loop.value = arrayExprValue;
            logger('containerSchema: ', containerSchema);
            logger(`【transformJSXChild】最终循环数组表达式: "${arrayExprValue}"`);
          } catch (error) {
            console.error(`【transformJSXChild】处理循环数组表达式时出错:`, error);
            containerSchema.loop.value = 'null';
          }

          try {
            // 处理遍历项的子节点
            if (jsxBody && t.isJSXElement(jsxBody)) {
              logger(`【transformJSXChild】处理map循环中的JSX元素`);
              containerSchema.children = [this.transformJSXElement(jsxBody)];
            } else if (
              jsxBody &&
              (t.isCallExpression(jsxBody) || t.isOptionalCallExpression(jsxBody)) &&
              t.isArrowFunctionExpression(jsxBody.callee) &&
              t.isJSXElement(jsxBody.callee.body)
            ) {
              logger(`【transformJSXChild】处理map循环中的函数调用JSX元素`);
              containerSchema.children = [this.transformJSXElement(jsxBody.callee?.body)];
            } else {
              logger(`【transformJSXChild】未能识别的map循环体类型:`, jsxBody?.type);
              logger(`【transformJSXChild】jsxBody详细信息:`, jsxBody);

              // 尝试回退处理：如果是表达式，尝试直接转换
              if (jsxBody) {
                try {
                  const fallbackResult = this.transformJSExpression(jsxBody);
                  logger(`【transformJSXChild】使用回退方案处理map循环体:`, fallbackResult);

                  // 创建一个简单的文本节点作为回退
                  containerSchema.children = [
                    {
                      componentName: 'Text',
                      props: {
                        children: {
                          type: 'JSExpression',
                          value: fallbackResult,
                        },
                      },
                    },
                  ];
                } catch (fallbackError) {
                  logger(`【transformJSXChild】回退方案也失败:`, fallbackError);
                  // 最后的回退：创建一个空的文本节点
                  containerSchema.children = [
                    {
                      componentName: 'Text',
                      props: {
                        children: '未知内容',
                      },
                    },
                  ];
                }
              }
            }

            logger(`【transformJSXChild】生成的循环容器:`, containerSchema);

            // 确保有有效的子节点
            if (!containerSchema.children || containerSchema.children.length === 0) {
              logger(`【transformJSXChild】警告：循环容器没有有效的子节点`);
              return null;
            }

            return {
              ...containerSchema?.children[0],
              loop: containerSchema.loop,
              loopArgs: containerSchema.loopArgs,
            };
          } finally {
            cleanup();
          }
        }
      }

      // 处理条件表达式
      if (t.isLogicalExpression(expression) || t.isUnaryExpression(expression)) {
        // 获取表达式的原始代码
        const { code } = generate(expression);
        logger(`【transformJSXChild】原始条件表达式: "${code}"`);
        logger(`【transformJSXChild】当前循环变量列表:`, this.currentLoopArgs);

        // 处理循环变量引用
        let expressionValue = code;

        // 先检查是否已经有this前缀
        const hasThisPrefix = expressionValue.includes('this.');
        logger(`【transformJSXChild】表达式是否已包含this前缀: ${hasThisPrefix}`);

        // 处理循环变量
        this.currentLoopArgs.forEach((arg) => {
          logger(`【transformJSXChild】处理循环变量: ${arg}`);

          // 直接处理形如 item1 或 item1?.property 或 item1.property 的所有情况
          // 修改正则表达式，不再期望arg后面有额外的数字
          const varPattern = new RegExp(`\\b(${arg})(?:\\??\\.[\\w\\.]+|\\b)`, 'g');
          logger(`【transformJSXChild】正则表达式模式: ${varPattern}`);
          logger(
            `【transformJSXChild】测试条件表达式: "${expressionValue}" 是否匹配正则: ${varPattern.test(
              expressionValue,
            )}`,
          );

          // 重置正则表达式的lastIndex，因为test方法会改变它
          varPattern.lastIndex = 0;

          if (varPattern.test(expressionValue)) {
            logger(`【transformJSXChild】找到循环变量 ${arg} 的匹配`);

            // 重置正则表达式的lastIndex
            varPattern.lastIndex = 0;

            // 先获取所有匹配项
            const matches = [];
            let match;
            const tempRegex = new RegExp(`\\b(${arg})(?:\\??\\.[\\w\\.]+|\\b)`, 'g');
            logger(`【transformJSXChild】临时正则表达式: ${tempRegex}`);

            // 手动测试一下匹配
            const testMatch = expressionValue.match(tempRegex);
            logger(`【transformJSXChild】手动测试匹配结果:`, testMatch);

            // 重置正则表达式
            tempRegex.lastIndex = 0;

            while ((match = tempRegex.exec(expressionValue)) !== null) {
              matches.push({
                full: match[0],
                varName: match[1],
              });
              logger(`【transformJSXChild】匹配到: ${match[0]}, 变量名: ${match[1]}`);
            }

            // 从最长的匹配开始处理，避免部分替换问题
            matches.sort((a, b) => b.full.length - a.full.length);

            for (const item of matches) {
              // 检查是否已经有this前缀
              if (expressionValue.includes(`this.${item.varName}`)) {
                logger(`【transformJSXChild】变量 ${item.varName} 已经有this前缀，跳过`);
                continue;
              }

              // 替换变量名为带this前缀的形式
              logger(`【transformJSXChild】为变量 ${item.varName} 添加this前缀`);
              const replaceRegex = new RegExp(`\\b${item.varName}\\b`, 'g');
              logger(`【transformJSXChild】替换正则表达式: ${replaceRegex}`);

              // 测试替换正则是否匹配
              logger(
                `【transformJSXChild】测试替换正则是否匹配: ${replaceRegex.test(expressionValue)}`,
              );
              replaceRegex.lastIndex = 0;

              const beforeReplace = expressionValue;
              expressionValue = expressionValue.replace(replaceRegex, `this.${item.varName}`);

              // 检查替换是否成功
              if (beforeReplace === expressionValue) {
                logger(`【transformJSXChild】警告: 替换未生效!`);
              } else {
                logger(`【transformJSXChild】替换成功: "${beforeReplace}" -> "${expressionValue}"`);
              }
            }
          }
        });

        // 处理感叹号前缀
        expressionValue = this.fixExclamationMarks(expressionValue);

        // 最后检查是否有重复的this前缀，如this.this.item，将其修正为this.item
        const thisRepeatPattern2 = /this\.this\./g;
        if (thisRepeatPattern2.test(expressionValue)) {
          logger(`【transformJSXChild】修复重复的this前缀`);
          expressionValue = expressionValue.replace(thisRepeatPattern2, 'this.');
        }

        logger(`【transformJSXChild】处理后的条件表达式: "${expressionValue}"`);
        logger(`【transformJSXChild】条件表达式最终结果:`, {
          type: 'JSExpression',
          value: expressionValue,
        });

        return {
          type: 'JSExpression',
          value: expressionValue,
        };
      }

      // 处理对象表达式中的条件
      if (t.isObjectExpression(expression)) {
        logger(`【transformJSXChild】处理对象表达式`);
        const obj: any = {};
        expression.properties.forEach((prop) => {
          if (t.isObjectProperty(prop)) {
            const key = t.isIdentifier(prop.key)
              ? prop.key.name
              : t.isStringLiteral(prop.key)
              ? prop.key.value
              : '';
            if (key) {
              logger(`【transformJSXChild】处理对象属性: ${key}, 值类型: ${prop.value.type}`);
              // 处理对象属性中的字面量值
              if (t.isNumericLiteral(prop.value)) {
                obj[key] = prop.value.value;
              } else if (t.isBooleanLiteral(prop.value)) {
                obj[key] = prop.value.value;
              } else if (t.isStringLiteral(prop.value)) {
                obj[key] = prop.value.value;
              } else if (t.isNullLiteral(prop.value)) {
                obj[key] = null;
              } else if (t.isJSXExpressionContainer(prop.value)) {
                const exprContainer = prop.value as t.JSXExpressionContainer;
                obj[key] = {
                  type: 'JSExpression',
                  value: this.transformJSExpression(exprContainer.expression),
                };
              } else if (t.isMemberExpression(prop.value)) {
                obj[key] = {
                  type: 'JSExpression',
                  value: this.transformJSExpression(prop.value),
                };
              } else if (t.isObjectExpression(prop.value)) {
                // 特殊处理 _unsafe_classNameJson 中的条件
                if (key === '_unsafe_classNameJson') {
                  logger('【transformJSXChild】开始处理 _unsafe_classNameJson:', prop.value);
                  const classNameJson = prop.value.properties.map((p) => {
                    if (t.isObjectProperty(p)) {
                      const propKey = t.isIdentifier(p.key) ? p.key.name : '';
                      logger('【transformJSXChild】处理 _unsafe_classNameJson 属性:', propKey);
                      if (propKey === 'condition') {
                        const { code } = generate(p.value);
                        let conditionValue = code;
                        logger('【transformJSXChild】原始条件表达式:', conditionValue);
                        logger('【transformJSXChild】条件表达式的 AST:', p.value);
                        logger('【transformJSXChild】当前循环变量列表:', this.currentLoopArgs);

                        // 处理循环变量
                        this.currentLoopArgs.forEach((arg) => {
                          logger('【transformJSXChild】处理循环变量:', arg);
                          // 处理父级循环变量
                          const parentArgPattern = new RegExp(
                            `\\b${arg}\\d+\\b(?!\\s*=)(?!\\.|\\\")`,
                            'g',
                          );
                          if (parentArgPattern.test(conditionValue)) {
                            logger('【transformJSXChild】找到父级循环变量:', arg);
                            conditionValue = conditionValue.replace(parentArgPattern, (match) => {
                              if (conditionValue.includes(`this.${match}`)) {
                                logger('【transformJSXChild】父级循环变量已有this前缀:', match);
                                return match;
                              }
                              logger('【transformJSXChild】为父级循环变量添加this前缀:', match);
                              return `this.${match}`;
                            });
                          }

                          // 处理父级循环变量的属性访问
                          const parentArgWithPropPattern = new RegExp(
                            `\\b${arg}\\d+(\\??\\.\\w+)`,
                            'g',
                          );
                          if (parentArgWithPropPattern.test(conditionValue)) {
                            logger('【transformJSXChild】找到带属性的父级循环变量:', arg);
                            conditionValue = conditionValue.replace(
                              parentArgWithPropPattern,
                              (match, prop) => {
                                if (conditionValue.includes(`this.${match}`)) {
                                  logger(
                                    '【transformJSXChild】带属性的父级循环变量已有this前缀:',
                                    match,
                                  );
                                  return match;
                                }
                                logger(
                                  '【transformJSXChild】为带属性的父级循环变量添加this前缀:',
                                  match,
                                );
                                return `this.${match}${prop}`;
                              },
                            );
                          }
                        });

                        // 处理JSSlot参数
                        logger('【transformJSXChild】当前JSSlot参数列表:', this.currentSlotParams);
                        this.currentSlotParams.forEach((param) => {
                          logger('【transformJSXChild】处理JSSlot参数:', param);

                          // 处理独立的JSSlot参数
                          const slotParamPattern = new RegExp(
                            `\\b${param}\\b(?!\\s*=)(?!\\.|\\\")`,
                            'g',
                          );
                          if (slotParamPattern.test(conditionValue)) {
                            logger('【transformJSXChild】找到JSSlot参数:', param);
                            conditionValue = conditionValue.replace(slotParamPattern, (match) => {
                              if (conditionValue.includes(`this.${match}`)) {
                                logger('【transformJSXChild】JSSlot参数已有this前缀:', match);
                                return match;
                              }
                              logger('【transformJSXChild】为JSSlot参数添加this前缀:', match);
                              return `this.${match}`;
                            });
                          }

                          // 处理JSSlot参数的属性访问
                          const slotParamWithPropPattern = new RegExp(
                            `\\b${param}(\\??\\.\\w+)`,
                            'g',
                          );
                          if (slotParamWithPropPattern.test(conditionValue)) {
                            logger('【transformJSXChild】找到带属性的JSSlot参数:', param);
                            conditionValue = conditionValue.replace(
                              slotParamWithPropPattern,
                              (match, prop) => {
                                if (conditionValue.includes(`this.${match}`)) {
                                  logger(
                                    '【transformJSXChild】带属性的JSSlot参数已有this前缀:',
                                    match,
                                  );
                                  return match;
                                }
                                logger(
                                  '【transformJSXChild】为带属性的JSSlot参数添加this前缀:',
                                  match,
                                );
                                return `this.${match}`;
                              },
                            );
                          }
                        });

                        logger('【transformJSXChild】处理后的条件表达式:', conditionValue);
                        logger('【transformJSXChild】条件表达式最终结果:', {
                          type: 'JSExpression',
                          value: conditionValue,
                        });

                        return {
                          ...(t.isObjectProperty(p)
                            ? {
                                [propKey]: {
                                  type: 'JSExpression',
                                  value: conditionValue,
                                },
                              }
                            : {}),
                          ...(t.isObjectProperty(p) &&
                          t.isIdentifier(p.key) &&
                          p.key.name === 'selector'
                            ? {
                                selector: t.isStringLiteral(p.value) ? p.value.value : '',
                              }
                            : {}),
                        };
                      }
                    }
                    return {};
                  });
                  logger('【transformJSXChild】_unsafe_classNameJson 最终结果:', classNameJson);
                  obj[key] = classNameJson;
                } else {
                  obj[key] = this.transformJSXAttributeValue({
                    type: 'JSXExpressionContainer',
                    expression: prop.value,
                  });
                }
              } else if (t.isArrayExpression(prop.value)) {
                obj[key] = this.transformArrayExpression(prop.value);
              } else {
                try {
                  let transformedValue;
                  if (
                    t.isStringLiteral(prop.value) ||
                    t.isJSXElement(prop.value) ||
                    (typeof t.isJSXFragment === 'function' && t.isJSXFragment(prop.value)) ||
                    t.isJSXExpressionContainer(prop.value) ||
                    prop.value === null
                  ) {
                    // 只有这几种类型才安全传递给 transformJSXAttributeValue
                    transformedValue = this.transformJSXAttributeValue(
                      prop.value as t.JSXAttribute['value'],
                    );
                  } else if (t.isExpression(prop.value)) {
                    transformedValue = {
                      type: 'JSExpression',
                      value: this.transformJSExpression(prop.value as t.Expression),
                    };
                  } else {
                    // 其它类型兜底
                    transformedValue = {
                      type: 'JSExpression',
                      value: '/* 处理错误 */',
                    };
                  }
                  obj[key] = transformedValue;
                } catch (error) {
                  console.error(`【transformJSXChild】处理对象属性 ${key} 时出错:`, error);
                  obj[key] = {
                    type: 'JSExpression',
                    value: '/* 处理错误 */',
                  };
                }
              }
            }
          }
        });
        return obj;
      }

      // 检查表达式是否包含 JSX（比如 map 函数返回 JSX）
      if (this.hasJSXInExpression(expression)) {
        logger(`【transformJSXChild】表达式包含JSX，需要特殊处理: ${expression.type}`);

        // 如果是包含 JSX 的 map 函数调用，让它继续走下面的 map 处理逻辑
        if (
          (t.isCallExpression(expression) || t.isOptionalCallExpression(expression)) &&
          expression.callee &&
          (t.isMemberExpression(expression.callee) ||
            t.isOptionalMemberExpression(expression.callee)) &&
          expression.callee.property &&
          t.isIdentifier(expression.callee.property) &&
          expression.callee.property.name === 'map'
        ) {
          logger(`【transformJSXChild】发现包含JSX的map函数调用，让它继续走map处理逻辑`);
          // 不在这里处理，让它继续走下面的 map 处理逻辑
        } else {
          // 对于其他包含 JSX 的表达式（非 map 函数），直接返回 JSExpression，不包装成 Text 组件
          logger(`【transformJSXChild】其他包含JSX的表达式，直接返回JSExpression`);

          // 对于包含 JSX 的表达式，我们不能调用 transformJSExpression，
          // 因为它不能正确处理 JSX，所以直接使用原始代码，但需要处理变量引用
          const { code } = generate(expression);
          logger(`【transformJSXChild】包含JSX的表达式原始代码: ${code}`);

          // 使用 transformJSFunctionAddThis 来处理变量引用，确保正确添加 this 前缀
          const processedCode = this.transformJSFunctionAddThis(code);
          logger(`【transformJSXChild】处理变量引用后的代码: ${processedCode}`);

          return {
            type: 'JSExpression',
            value: processedCode,
          };
        }
      }

      // 对于其他简单表达式（如 {item}），转换为JSExpression
      logger(`【transformJSXChild】处理简单表达式: ${expression.type}`);
      const { code } = generate(expression);
      logger(`【transformJSXChild】简单表达式原始代码: "${code}"`);

      // 处理循环变量引用，确保正确添加this前缀
      let expressionValue = code;

      // 检查是否是解构变量、循环变量或JSSlot参数
      if (t.isIdentifier(expression)) {
        const isDestructuredVar = this.allDestructuredVars.includes(expression.name);
        const isLoopArg = this.allLoopArgs.includes(expression.name);
        const isSlotParam = this.currentSlotParams.includes(expression.name);
        logger(
          `【transformJSXChild】标识符: ${expression.name}, 是否是解构变量: ${isDestructuredVar}, 是否是循环变量: ${isLoopArg}, 是否是JSSlot参数: ${isSlotParam}`,
        );

        // 如果是解构变量，使用映射的数组访问形式
        if (isDestructuredVar) {
          const mapping = this.destructuredVarMappings.get(expression.name);
          if (mapping) {
            logger(`【transformJSXChild】替换解构变量 ${expression.name} 为 ${mapping}`);
            expressionValue = mapping;
          }
        } else if (isLoopArg || isSlotParam) {
          logger(`【transformJSXChild】为变量 ${expression.name} 添加this前缀`);
          expressionValue = `this.${expression.name}`;
        }
      } else {
        // 对于非Identifier表达式，使用transformJSExpression处理
        expressionValue = this.transformJSExpression(expression);
      }

      logger(`【transformJSXChild】简单表达式处理结果: "${expressionValue}"`);

      // 如果父组件是文本类组件，直接返回JSExpression，不包装成Text组件
      if (parentComponentName && this.isTextComponent(parentComponentName)) {
        logger(
          `【transformJSXChild】父组件${parentComponentName}是文本类组件，直接返回JSExpression`,
        );
        return {
          type: 'JSExpression',
          value: expressionValue,
        };
      }

      // 如果是渲染组件的方法调用，直接返回JSExpression，不包装成Text组件
      if (this.isRenderComponentCall(expression)) {
        logger(`【transformJSXChild】发现渲染组件方法调用，直接返回JSExpression，不包装成Text组件`);
        return {
          type: 'JSExpression',
          value: expressionValue,
        };
      }

      // 对于其他情况，将JSExpression包装成Text组件，确保所有节点都可以在画布中选择
      return {
        componentName: 'Text',
        props: {
          children: {
            type: 'JSExpression',
            value: expressionValue,
          },
        },
        children: [],
      };
    }

    if (t.isJSXFragment(child)) {
      logger(`【transformJSXChild】处理JSX Fragment`);
      return {
        componentName: 'View', // 直接使用View而不是Fragment
        children: child.children
          .filter((child) => !t.isJSXText(child) || child.value.trim())
          .map((child) => this.transformJSXChild(child, 'View')), // 这里也改为View
      };
    }

    return null;
  }

  private transformJSXElement(element: t.JSXElement): IPublicTypeNodeSchema {
    const schema: IPublicTypeNodeSchema = {
      componentName: '',
      props: {},
      children: [],
    };

    if (!element.openingElement) {
      return schema;
    }

    // 处理组件名，支持 Form.Item 这种复合组件名
    if (t.isJSXIdentifier(element.openingElement?.name)) {
      schema.componentName = element.openingElement.name.name;
      // 新增：收集组件名
      this.usedComponentNames.add(schema.componentName);
    } else if (t.isJSXMemberExpression(element.openingElement?.name)) {
      // 处理复合组件名，如 Form.Item
      const parts: string[] = [];
      let current: t.JSXMemberExpression | t.JSXIdentifier = element.openingElement.name;

      while (t.isJSXMemberExpression(current)) {
        if (t.isJSXIdentifier(current.property)) {
          parts.unshift(current.property.name);
        }
        current = current.object;
      }

      if (t.isJSXIdentifier(current)) {
        parts.unshift(current.name);
      }

      schema.componentName = parts.join('.');
      // 新增：收集复合组件名
      this.usedComponentNames.add(schema.componentName);
    }

    // 处理属性
    element.openingElement?.attributes.forEach((attr) => {
      if (t.isJSXAttribute(attr)) {
        let propName = attr.name.name as string;
        let propValue = this.transformJSXAttributeValue(attr.value, schema.componentName, propName);

        // HTML 到 JSX 转换：只转换必要的属性
        // class -> className (data-* 和 aria-* 属性保持原样)
        if (propName === 'class') {
          propName = 'className';
        }
        // 其他需要转换的 HTML 属性可以在这里添加
        // 注意：data-* 和 aria-* 属性在 JSX 中保持原样，不需要转换

        // 特殊处理 style 属性：如果是字符串，转换为对象
        if (propName === 'style' && typeof propValue === 'string') {
          propValue = this.parseStyleString(propValue);
          logger(`【transformJSXElement】将 style 字符串转换为对象:`, propValue);
        }

        logger('propValue: ', attr.value, propValue);
        if (propValue !== undefined) {
          schema.props[propName] = propValue;
        }
      }
    });

    // 转换组件名
    schema.componentName = this.transformComponentName(schema) || schema.componentName;

    // 检查Tailwind样式互转
    const nodeClassName = schema.props.className as string;
    logger('nodeClassName: ', nodeClassName, schema.props.style);

    // 检查 style 是否包含 JSExpression
    const hasJSExpressionInStyle = this.hasJSExpressionInStyle(schema.props.style);
    logger('hasJSExpressionInStyle: ', hasJSExpressionInStyle);

    const needTransformStyle =
      !!nodeClassName && this.shouldTransformClassName(nodeClassName) && !hasJSExpressionInStyle;
    if (needTransformStyle) {
      // 保存原有的 style 属性
      const originalStyle = schema.props.style;

      // 进行Tailwind classNameToStyle 的转换
      const styleAboutProps = classToStyle(nodeClassName, {
        // globalStyles: this.globalStyles,
        // fileStyles: this.fileStyles,
        // variables: this.variables,
      });

      if (styleAboutProps.style) {
        // 合并样式时，优先保留原有的 style 属性
        if (originalStyle && typeof originalStyle === 'string') {
          // 如果原有 style 是字符串，需要解析并合并
          const mergedStyle = this.mergeStyleWithString(originalStyle, styleAboutProps.style);
          schema.props = {
            ...schema.props,
            ...styleAboutProps,
            style: mergedStyle,
          };
        } else if (originalStyle && typeof originalStyle === 'object') {
          // 如果原有 style 是对象，直接合并
          schema.props = {
            ...schema.props,
            ...styleAboutProps,
            style: { ...styleAboutProps.style, ...originalStyle },
          };
        } else {
          // 没有原有 style，直接使用转换后的
          schema.props = { ...schema.props, ...styleAboutProps };
        }
      }

      logger('styleAboutProps: ', nodeClassName, styleAboutProps);
      if (schema.props.className) {
        // @ts-ignore
        window.unconvertedClasses = {
          ...(window.unconvertedClasses || {}),
          [nodeClassName]: true,
        };
      }
    }

    // 处理代码ref到SchemaRef
    if (schema.props.ref && isJSExpression(schema.props.ref)) {
      schema.props.ref = schema.props.ref.value.match(/\"([^\"]+)\"/)?.[1] || '';
    }

    // 处理子节点
    const children = element.children
      .filter((child) => !t.isJSXText(child) || child.value.trim())
      .map((child, index, array) => {
        // 如果当前节点已被处理（作为混合文本的一部分），则跳过
        if (this.isNodeProcessed(child)) {
          return null;
        }
        return this.transformJSXChild(child, schema.componentName);
      })
      .filter(Boolean) // 过滤掉null值
      .flat(); // 展开可能的数组结果（条件表达式拆分的情况）

    // 检查是否需要合并混合文本内容（适用于p、span等可能包含文本的标签）
    const shouldMergeMixedContent = [
      'p',
      'span',
      'h1',
      'h2',
      'h3',
      'h4',
      'h5',
      'h6',
      'div',
    ].includes(schema.componentName.toLowerCase());

    if (shouldMergeMixedContent && children.length > 1) {
      // 检查是否包含混合内容（文本 + 表达式）
      const hasMixedContent =
        children.some((child) => typeof child === 'string') &&
        children.some(
          (child) =>
            child &&
            typeof child === 'object' &&
            child.componentName === 'Text' &&
            child.props.children &&
            child.props.children.type === 'JSExpression',
        );

      if (hasMixedContent) {
        logger(
          `【transformJSXElement】检测到${schema.componentName}中的混合文本内容，合并为模板字符串`,
        );

        // 将所有children合并为一个模板字符串表达式
        const templateParts = children.map((child) => {
          if (typeof child === 'string') {
            return child;
          } else if (
            child &&
            typeof child === 'object' &&
            child.componentName === 'Text' &&
            child.props.children &&
            child.props.children.type === 'JSExpression'
          ) {
            return `\${${child.props.children.value}}`;
          }
          return '';
        });

        const mergedTemplate = `\`${templateParts.join('')}\``;
        logger(`【transformJSXElement】合并后的模板字符串: ${mergedTemplate}`);

        schema.props.children = {
          type: 'JSExpression',
          value: mergedTemplate,
        };
        schema.children = [];
        return schema;
      }
    }

    // 对于 Text 组件，我们需要特殊处理
    if (schema.componentName === 'Text') {
      if (children.length === 1) {
        // 检查是否是包装后的JSExpression（由transformJSXChild处理后的结果）
        if (
          children[0] &&
          typeof children[0] === 'object' &&
          children[0].componentName === 'Text' &&
          children[0].props.children &&
          children[0].props.children.type === 'JSExpression'
        ) {
          schema.props.children = children[0].props.children;
        } else {
          // 保持原有逻辑
          schema.props.children = children[0];
        }
        // 清空 schema.children 以避免重复
        schema.children = [];
      } else if (children.length > 1) {
        // 如果还有多个子节点，说明可能有其他复杂的JSX结构，保持原有的children数组
        schema.children = children;
      }
    } else if (this.isTextComponent(schema.componentName)) {
      // 对于文本类组件（H1、H2、H3、H4、H5、H6、p、span等）
      if (children.length === 1) {
        if (typeof children[0] === 'string') {
          // 纯字符串：直接使用props.children
          logger(
            `【transformJSXElement】文本类组件${schema.componentName}直接使用字符串作为children: "${children[0]}"`,
          );
          schema.props.children = children[0];
          schema.children = [];
        } else if (
          children[0] &&
          typeof children[0] === 'object' &&
          children[0].componentName === 'Text' &&
          children[0].props.children &&
          typeof children[0].props.children === 'string'
        ) {
          // 简单的Text组件（纯字符串）：提取其children
          logger(
            `【transformJSXElement】文本类组件${schema.componentName}提取Text子组件的字符串children`,
          );
          schema.props.children = children[0].props.children;
          schema.children = [];
        } else {
          // 检查是否是单个 JSExpression
          if (
            children.length === 1 &&
            children[0] &&
            typeof children[0] === 'object' &&
            children[0].type === 'JSExpression'
          ) {
            logger(
              `【transformJSXElement】文本类组件${schema.componentName}包含单个JSExpression，放入props.children`,
            );
            schema.props.children = children[0];
            schema.children = [];
          } else {
            // 其他复杂结构：走正常的JSX处理流程，使用children数组
            logger(
              `【transformJSXElement】文本类组件${schema.componentName}包含复杂结构，使用children数组`,
            );
            schema.children = children;
          }
        }
      } else if (children.length > 1) {
        // 对于多个子节点，检查是否都是字符串或简单表达式
        const allSimpleContent = children.every(
          (child) =>
            typeof child === 'string' ||
            (child &&
              typeof child === 'object' &&
              child.componentName === 'Text' &&
              child.props.children),
        );

        if (allSimpleContent) {
          // 将多个简单内容合并为模板字符串
          const templateParts = children.map((child) => {
            if (typeof child === 'string') {
              return child;
            } else if (
              child &&
              typeof child === 'object' &&
              child.componentName === 'Text' &&
              child.props.children &&
              child.props.children.type === 'JSExpression'
            ) {
              return `\${${child.props.children.value}}`;
            }
            return '';
          });

          const mergedTemplate = `\`${templateParts.join('')}\``;
          logger(
            `【transformJSXElement】文本类组件${schema.componentName}合并多个内容为模板字符串: ${mergedTemplate}`,
          );

          schema.props.children = {
            type: 'JSExpression',
            value: mergedTemplate,
          };
          schema.children = [];
        } else {
          // 如果有复杂的子节点，保持children数组
          schema.children = children;
        }
      }
    } else {
      // 检查是否是纯文本内容组件（如option、button等）
      logger(
        `【transformJSXElement】检查组件 ${schema.componentName} 是否为纯文本组件:`,
        this.isPureTextContentComponent(schema.componentName),
      );
      logger(`【transformJSXElement】组件 ${schema.componentName} 的 children:`, children);

      if (this.isPureTextContentComponent(schema.componentName)) {
        // 纯文本内容组件：直接使用props.children，不包装成Text组件
        if (children.length === 1) {
          if (typeof children[0] === 'string') {
            logger(
              `【transformJSXElement】纯文本内容组件${schema.componentName}直接使用字符串作为children: "${children[0]}"`,
            );
            schema.props.children = children[0];
          } else {
            // 检查是否是单个 JSExpression
            if (
              children.length === 1 &&
              children[0] &&
              typeof children[0] === 'object' &&
              children[0].type === 'JSExpression'
            ) {
              logger(
                `【transformJSXElement】纯文本组件${schema.componentName}包含单个JSExpression，放入props.children`,
              );
              schema.props.children = children[0];
            } else if (this.shouldConvertToJSSlot(children)) {
              // 检查是否需要转换为 JSSlot（条件渲染的情况）
              logger(`【transformJSXElement】纯文本组件${schema.componentName}转换为JSSlot`);
              schema.props.children = this.convertToJSSlot(children);
            } else {
              schema.props.children = children[0];
            }
          }
          schema.children = [];
        } else if (children.length > 1) {
          // 多个子节点合并为模板字符串
          const allTextContent = children.every(
            (child) =>
              typeof child === 'string' ||
              (child &&
                typeof child === 'object' &&
                child.componentName === 'Text' &&
                child.props.children),
          );

          if (allTextContent) {
            const templateParts = children.map((child) => {
              if (typeof child === 'string') {
                return child;
              } else if (
                child &&
                typeof child === 'object' &&
                child.componentName === 'Text' &&
                child.props.children &&
                child.props.children.type === 'JSExpression'
              ) {
                return `\${${child.props.children.value}}`;
              }
              return '';
            });

            const mergedTemplate = `\`${templateParts.join('')}\``;
            logger(
              `【transformJSXElement】纯文本内容组件${schema.componentName}合并多个内容为模板字符串: ${mergedTemplate}`,
            );

            schema.props.children = {
              type: 'JSExpression',
              value: mergedTemplate,
            };
            schema.children = [];
          } else {
            schema.children = children;
          }
        }
      } else {
        // 对于其他组件，确保所有文本都被包装成Text组件
        if (children.length === 1) {
          if (typeof children[0] === 'string') {
            // 将单个字符串包装成Text组件，而不是直接设置为props.children
            logger(
              `【transformJSXElement】将${schema.componentName}中的单个字符串包装成Text组件: "${children[0]}"`,
            );
            schema.children = [
              {
                componentName: 'Text',
                props: {
                  children: children[0],
                },
                children: [],
              },
            ];
          } else {
            // 修复bug：不要将Text组件的children提取到父组件，而是保持Text组件作为子组件
            schema.children = children;
          }
        } else {
          // 处理多个子节点时，将字符串包装成Text组件
          logger(
            `【transformJSXElement】处理${schema.componentName}中的多个子节点，包装字符串为Text组件`,
          );

          // 所有字符串都包装成Text组件
          schema.children = children.map((child) => {
            if (typeof child === 'string') {
              logger(`【transformJSXElement】包装字符串为Text组件: "${child}"`);
              return {
                componentName: 'Text',
                props: {
                  children: child,
                },
                children: [],
              };
            }
            return child;
          });
        }
      }
    }

    return schema;
  }

  transformComponentName(schema: IPublicTypeNodeSchema): string {
    if (schema.componentName === 'div') {
      return 'View';
    }
    if (schema.componentName === 'span') {
      return 'Text';
    }
    if (schema.componentName === 'img') {
      return 'Image';
    }
    if (schema.componentName === 'Fragment') {
      return 'View';
    }
    // 默认返回原组件名
    return schema.componentName;
  }

  // 判断条件表达式中是否包含 JSX 元素（支持嵌套条件表达式）
  private hasJSXInConditional(expression: t.ConditionalExpression): boolean {
    logger(`【hasJSXInConditional】检查条件表达式是否包含JSX`);
    logger(`【hasJSXInConditional】consequent类型: ${expression.consequent.type}`);
    logger(`【hasJSXInConditional】alternate类型: ${expression.alternate.type}`);

    const hasJSXInConsequent = this.hasJSXInExpression(expression.consequent);
    const hasJSXInAlternate = this.hasJSXInExpression(expression.alternate);

    logger(`【hasJSXInConditional】consequent包含JSX: ${hasJSXInConsequent}`);
    logger(`【hasJSXInConditional】alternate包含JSX: ${hasJSXInAlternate}`);

    const result = hasJSXInConsequent || hasJSXInAlternate;
    logger(`【hasJSXInConditional】最终结果: ${result}`);

    return result;
  }

  // 通用方法：判断表达式中是否包含 JSX 元素
  private hasJSXInExpression(node: t.Expression): boolean {
    // 直接的 JSX 元素或片段
    if (t.isJSXElement(node) || t.isJSXFragment(node)) {
      return true;
    }

    // 嵌套的条件表达式
    if (t.isConditionalExpression(node)) {
      return this.hasJSXInConditional(node);
    }

    // 逻辑表达式（如 && 或 ||）
    if (t.isLogicalExpression(node)) {
      return this.hasJSXInExpression(node.left) || this.hasJSXInExpression(node.right);
    }

    // 序列表达式（如 (expr1, expr2)）
    if (t.isSequenceExpression(node)) {
      return node.expressions.some((expr) => this.hasJSXInExpression(expr));
    }

    // 赋值表达式（如 a = <div/>）
    if (t.isAssignmentExpression(node)) {
      return this.hasJSXInExpression(node.right);
    }

    // 函数调用表达式（可能返回 JSX）
    if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
      // 检查参数中是否有 JSX
      const hasJSXInArgs = node.arguments.some(
        (arg) => t.isExpression(arg) && this.hasJSXInExpression(arg),
      );
      if (hasJSXInArgs) {
        return true;
      }

      // 特别检查 map 函数调用是否返回 JSX
      if (
        (t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)) &&
        t.isIdentifier(node.callee.property) &&
        node.callee.property.name === 'map'
      ) {
        logger(`【hasJSXInExpression】检查map函数调用是否返回JSX`);
        const mapCallback = node.arguments[0];

        if (t.isArrowFunctionExpression(mapCallback) || t.isFunctionExpression(mapCallback)) {
          // 检查回调函数是否返回 JSX
          if (t.isBlockStatement(mapCallback.body)) {
            // 函数体形式：(item) => { return <JSX/> }
            const returnStatement = mapCallback.body.body.find((stmt) => t.isReturnStatement(stmt));
            if (
              returnStatement &&
              t.isReturnStatement(returnStatement) &&
              returnStatement.argument
            ) {
              const hasJSXInReturn = this.hasJSXInExpression(returnStatement.argument);
              logger(`【hasJSXInExpression】map回调函数体返回值包含JSX: ${hasJSXInReturn}`);
              return hasJSXInReturn;
            }
          } else if (t.isExpression(mapCallback.body)) {
            // 表达式形式：(item) => <JSX/>
            const hasJSXInBody = this.hasJSXInExpression(mapCallback.body);
            logger(`【hasJSXInExpression】map回调函数表达式包含JSX: ${hasJSXInBody}`);
            return hasJSXInBody;
          }
        }
      }
    }

    return false;
  }

  // 判断是否应该转换为 JSSlot（检查children数组中是否有条件渲染）
  private shouldConvertToJSSlot(children: any[]): boolean {
    if (!Array.isArray(children) || children.length === 0) {
      return false;
    }

    // 检查是否有条件渲染的组件
    return children.some((child) => child && typeof child === 'object' && child.condition);
  }

  // 转换为 JSSlot
  private convertToJSSlot(children: any[]): any {
    if (this.shouldConvertToJSSlot(children)) {
      return {
        type: 'JSSlot',
        value: children,
      };
    }
    return children[0]; // 如果不需要转换，返回第一个元素
  }

  // 判断是否是文本类组件（这些组件本身就是用来放文本的，不需要再套Text组件）
  private isTextComponent(componentName: string): boolean {
    const textComponents = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'span', 'Text'];
    return textComponents.includes(componentName.toLowerCase());
  }

  // 判断是否是纯文本内容组件（这些组件的文本子节点应该保持为纯字符串，不包装成Text组件）
  private isPureTextContentComponent(componentName: string): boolean {
    const pureTextComponents = [
      // 表单元素
      'option',
      'button',
      'label',
      'legend',
      'optgroup',
      // 表格元素
      'th',
      'td',
      'caption',
      // 列表元素
      'li',
      'dt',
      'dd',
      // 其他语义化元素
      'title',
      'summary',
      'figcaption',
      // 文本类组件也应该保持纯文本
      ...['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'span', 'Text'],
    ];
    return pureTextComponents.includes(componentName.toLowerCase());
  }

  // 判断表达式是否是渲染组件的方法调用或ReactNode属性访问（这些不应该被包装成Text组件）
  private isRenderComponentCall(expression: t.Expression): boolean {
    // 检查函数调用
    if (t.isCallExpression(expression)) {
      // 检查是否是成员表达式调用，如 this.utils.renderComponent()
      if (
        t.isMemberExpression(expression.callee) ||
        t.isOptionalMemberExpression(expression.callee)
      ) {
        const property = t.isIdentifier(expression.callee.property)
          ? expression.callee.property.name
          : '';

        if (this.renderComponentWhitelist.has(property)) {
          logger(`【isRenderComponentCall】发现渲染组件方法调用: ${property}`);
          return true;
        }
      }

      // 检查是否是直接函数调用，如 renderComponent()
      if (t.isIdentifier(expression.callee)) {
        const functionName = expression.callee.name;
        if (this.renderComponentWhitelist.has(functionName)) {
          logger(`【isRenderComponentCall】发现渲染组件函数调用: ${functionName}`);
          return true;
        }
      }
    }

    // 检查成员表达式访问，如 this.props.children（ReactNode属性）
    if (t.isMemberExpression(expression) || t.isOptionalMemberExpression(expression)) {
      const property = t.isIdentifier(expression.property) ? expression.property.name : '';

      if (this.renderComponentWhitelist.has(property)) {
        logger(`【isRenderComponentCall】发现ReactNode属性访问: ${property}`);
        return true;
      }
    }

    return false;
  }

  // 处理数组解构的箭头函数
  private transformArrayDestructuringFunction(expr: t.ArrowFunctionExpression): string {
    logger('转换数组解构函数:', expr);

    const isAsync = expr.async ? 'async ' : '';

    // 生成新的参数名，基于数组解构的语义
    let newParamName = 'item'; // 默认参数名

    // 尝试从上下文推断更好的参数名
    // 如果是 Object.entries().map，使用 'entry'
    // 如果是其他数组的 map，使用 'item'
    const contextHints = ['entry', 'pair', 'tuple', 'item'];
    newParamName = contextHints[0]; // 暂时使用 'entry'，后续可以根据上下文优化

    try {
      // 处理数组解构参数
      const arrayParam = expr.params.find((param) => t.isArrayPattern(param)) as t.ArrayPattern;
      if (!arrayParam) {
        // 如果没有找到数组解构，回退到原始处理
        return this.transformArrowFunctionToNormalFunction(expr);
      }

      // 提取解构的变量名
      const destructuredVars: string[] = [];
      arrayParam.elements.forEach((element, index) => {
        if (t.isIdentifier(element)) {
          destructuredVars.push(element.name);
        } else {
          // 对于复杂模式，使用默认名称
          destructuredVars.push(`item${index}`);
        }
      });

      logger('解构的变量:', destructuredVars);

      // 保存当前的解构变量映射
      const prevDestructuredVars = [...this.currentDestructuredVars];
      const prevMappings = new Map(this.destructuredVarMappings);

      // 更新解构变量映射关系
      destructuredVars.forEach((varName, index) => {
        const mapping = `this.${newParamName}[${index}]`;
        this.destructuredVarMappings.set(varName, mapping);
        this.currentDestructuredVars.push(varName);
        if (!this.allDestructuredVars.includes(varName)) {
          this.allDestructuredVars.push(varName);
        }
        logger(`【transformArrayDestructuringFunction】添加解构变量映射: ${varName} -> ${mapping}`);
      });

      // 生成解构赋值语句
      const destructuringStatements = destructuredVars
        .map((varName, index) => {
          return `const ${varName} = ${newParamName}[${index}];`;
        })
        .join('\n  ');

      // 处理函数体
      let bodyCode = '';
      if (t.isBlockStatement(expr.body)) {
        // 如果是代码块
        bodyCode = generate(expr.body).code;
      } else {
        // 如果是表达式，需要包装成 return 语句
        const exprCode = generate(expr.body).code;
        bodyCode = `{\n  return ${exprCode};\n}`;
      }

      // 移除外层的大括号，因为我们要插入解构语句
      const cleanBodyCode = bodyCode.replace(/^{\s*/, '').replace(/\s*}$/, '');

      // 组合最终的函数体
      const finalBodyCode = `{\n  ${destructuringStatements}\n  ${cleanBodyCode}\n}`;

      // 应用变量转换
      const validatedCode = this.transformJSFunctionAddThis(finalBodyCode, [
        newParamName,
        ...destructuredVars,
      ]);

      const result = `${isAsync}function(${newParamName}) ${validatedCode}`;
      logger('数组解构转换结果:', result);

      // 恢复之前的解构变量状态
      this.currentDestructuredVars = prevDestructuredVars;
      this.destructuredVarMappings = prevMappings;

      return result;
    } catch (error) {
      logger('数组解构转换失败，回退到原始处理:', error);
      // 回退到原始处理，但移除数组解构参数
      const simpleParams = expr.params.filter((param) => !t.isArrayPattern(param));
      const newExpr = { ...expr, params: simpleParams };
      return this.transformArrowFunctionToNormalFunction(newExpr as t.ArrowFunctionExpression);
    }
  }

  private transformArrowFunctionToNormalFunction(expr: t.ArrowFunctionExpression): string {
    logger('将箭头函数转换为普通函数:', expr);

    const isAsync = expr.async ? 'async ' : '';

    // 检查是否有数组解构参数，如果有则转换
    const hasArrayDestructuring = expr.params.some((param) => t.isArrayPattern(param));

    if (hasArrayDestructuring) {
      logger('检测到数组解构参数，进行转换');
      return this.transformArrayDestructuringFunction(expr);
    }

    try {
      // 处理函数参数
      const params = expr.params
        .map((param) => {
          try {
            return generate(param).code;
          } catch (e) {
            console.error('生成参数代码失败:', e);
            if (t.isIdentifier(param)) {
              return param.name;
            }
            return '...'; // 对于复杂参数模式，简化处理
          }
        })
        .join(', ');

      // 处理函数体
      let bodyCode = '';

      if (t.isBlockStatement(expr.body)) {
        // 如果是代码块，直接生成整个代码块
        try {
          bodyCode = generate(expr.body).code;
          logger('生成的函数体代码块:', bodyCode);
        } catch (e) {
          console.error('生成函数体代码块失败:', e);
          // 失败时回退到原来的处理方式
          bodyCode = this.processBlockStatement(expr.body);
        }
      } else {
        // 如果是表达式，生成return语句
        try {
          const exprCode = generate(expr.body).code;
          logger('生成的表达式代码:', exprCode);
          bodyCode = `{ return ${exprCode}; }`;
        } catch (e) {
          console.error('生成表达式代码失败:', e);
          // 失败时回退到原来的处理方式
          // 先设置函数参数，再处理表达式
          const paramNames: string[] = [];
          expr.params.forEach((param) => {
            if (t.isIdentifier(param)) {
              paramNames.push(param.name);
            } else if (t.isArrayPattern(param)) {
              // 处理数组解构参数，如 [key, type]
              param.elements.forEach((element) => {
                if (t.isIdentifier(element)) {
                  paramNames.push(element.name);
                }
              });
            }
          });

          const prevFunctionParams = [...this.currentFunctionParams];
          this.currentFunctionParams = paramNames;

          try {
            bodyCode = `{ return ${this.transformJSExpression(expr.body)}; }`;
          } finally {
            this.currentFunctionParams = prevFunctionParams;
          }
        }
      }

      // 提取函数参数名列表，包括数组解构参数
      const paramNames: string[] = [];
      expr.params.forEach((param) => {
        if (t.isIdentifier(param)) {
          paramNames.push(param.name);
        } else if (t.isArrayPattern(param)) {
          // 处理数组解构参数，如 [key, type]
          param.elements.forEach((element) => {
            if (t.isIdentifier(element)) {
              paramNames.push(element.name);
            }
          });
        }
        // 可以在这里添加对其他参数类型的处理，如对象解构等
      });

      // 保存当前函数参数状态
      const prevFunctionParams = [...this.currentFunctionParams];
      this.currentFunctionParams = paramNames;

      try {
        const validatedCode = this.transformJSFunctionAddThis(bodyCode, paramNames);
        return `${isAsync}function(${params}) ${validatedCode}`;
      } finally {
        // 恢复之前的函数参数状态
        this.currentFunctionParams = prevFunctionParams;
      }
    } catch (error) {
      console.error('使用generate生成函数代码失败:', error);

      // 失败时回退到原来的处理方式
      // 处理函数参数
      const params = expr.params
        .map((param) => {
          if (t.isIdentifier(param)) {
            return param.name;
          }
          return '...'; // 对于复杂参数模式，简化处理
        })
        .join(', ');

      // 处理函数体
      let bodyCode = '';
      if (t.isBlockStatement(expr.body)) {
        bodyCode = this.processBlockStatement(expr.body);
      } else {
        bodyCode = `{ return ${this.transformJSExpression(expr.body)}; }`;
      }

      // 提取函数参数名列表，包括数组解构参数
      const paramNames: string[] = [];
      expr.params.forEach((param) => {
        if (t.isIdentifier(param)) {
          paramNames.push(param.name);
        } else if (t.isArrayPattern(param)) {
          // 处理数组解构参数，如 [key, type]
          param.elements.forEach((element) => {
            if (t.isIdentifier(element)) {
              paramNames.push(element.name);
            }
          });
        }
      });

      // 使用统一的 transformJSFunctionAddThis 方法处理 this 前缀
      bodyCode = this.transformJSFunctionAddThis(bodyCode, paramNames);

      return `${isAsync}function(${params}) ${bodyCode}`;
    }
  }

  // 辅助方法：处理代码块
  private processBlockStatement(block: t.BlockStatement): string {
    try {
      // 尝试直接生成整个代码块
      return generate(block).code;
    } catch (e) {
      console.error('直接生成代码块失败，回退到逐语句处理:', e);

      // 逐语句处理
      return block.body
        .map((statement) => {
          try {
            // 尝试直接生成语句代码
            return generate(statement).code;
          } catch (statementError) {
            console.error('生成语句代码失败:', statementError);

            // 特殊处理各种语句类型
            if (t.isReturnStatement(statement)) {
              return `return ${
                statement.argument ? this.transformJSExpression(statement.argument) : ''
              }`;
            }
            if (t.isExpressionStatement(statement)) {
              return this.transformJSExpression(statement.expression);
            }
            if (t.isVariableDeclaration(statement)) {
              const declarations = statement.declarations
                .map((declarator) => {
                  const id = t.isIdentifier(declarator.id)
                    ? declarator.id.name
                    : generate(declarator.id).code;
                  const init = declarator.init
                    ? this.transformJSExpression(declarator.init)
                    : 'undefined';
                  return `${id} = ${init}`;
                })
                .join(', ');
              return `${statement.kind} ${declarations}`;
            }

            // 对于其他不支持的语句类型，返回注释
            return `/* 不支持的语句类型: ${statement.type} */`;
          }
        })
        .join(';\n  ');
    }
  }

  // 添加一个辅助方法来修复感叹号问题
  private fixExclamationMarks(expr: string): string {
    // 修复多个感叹号的情况，如 !!!! 改为 !!
    return expr.replace(/!{3,}/g, '!!');
  }

  private transformStateValue(value: t.Expression): any {
    // 处理字面量，直接返回原始值
    if (t.isStringLiteral(value)) {
      return value.value;
    }
    if (t.isNumericLiteral(value)) {
      return value.value;
    }
    if (t.isBooleanLiteral(value)) {
      return value.value;
    }
    if (t.isNullLiteral(value)) {
      return null;
    }
    if (t.isIdentifier(value) && value.name === 'undefined') {
      return undefined;
    }

    // 处理数组
    if (t.isArrayExpression(value)) {
      // 先转换所有元素
      const transformedElements = value.elements.map((element) => {
        if (!element) return null;
        // 只处理Expression类型，其他类型转换为JSExpression
        if (t.isExpression(element)) {
          return this.transformStateValue(element);
        }
        // 对于其他类型（如SpreadElement），使用generate生成代码
        try {
          return {
            type: 'JSExpression',
            value: generate(element).code,
          };
        } catch (error) {
          return {
            type: 'JSExpression',
            value: '/* 不支持的数组元素类型 */',
          };
        }
      });

      // 检查是否所有元素都是简单值（不包含JSExpression）
      const isSimpleArray = transformedElements.every((element) => {
        // null、undefined、基本类型都是简单的
        if (element === null || element === undefined || typeof element !== 'object') {
          return true;
        }
        // 如果是对象但不是JSExpression，也是简单的（比如纯字面量对象、数组）
        return !(element.type === 'JSExpression');
      });

      if (isSimpleArray) {
        return transformedElements;
      }
    }

    // 处理对象
    if (t.isObjectExpression(value)) {
      const obj: any = {};
      let isSimpleObject = true;

      for (const prop of value.properties) {
        if (!t.isObjectProperty(prop)) {
          isSimpleObject = false;
          break;
        }

        const key = t.isIdentifier(prop.key)
          ? prop.key.name
          : t.isStringLiteral(prop.key)
          ? prop.key.value
          : '';

        if (!key) {
          isSimpleObject = false;
          break;
        }

        // 递归处理属性值
        const propValue = this.transformStateValue(prop.value as t.Expression);
        // 如果属性值是JSExpression，说明包含复杂表达式，整个对象就不是简单对象
        if (propValue && typeof propValue === 'object' && propValue.type === 'JSExpression') {
          isSimpleObject = false;
          break;
        }
        obj[key] = propValue;
      }

      if (isSimpleObject) {
        return obj;
      }
    }

    // 对于其他所有情况，转换为 JSExpression
    return {
      type: 'JSExpression',
      value: this.transformJSExpression(value),
    };
  }

  // 修改处理 state 的代码
  private processClassProperty(node: t.ClassProperty) {
    if (t.isIdentifier(node.key) && node.key.name === 'state' && node.value) {
      if (t.isObjectExpression(node.value)) {
        const stateObj: Record<string, any> = {};
        node.value.properties.forEach((prop) => {
          if (t.isObjectProperty(prop)) {
            const key = t.isIdentifier(prop.key)
              ? prop.key.name
              : t.isStringLiteral(prop.key)
              ? prop.key.value
              : '';

            if (key) {
              stateObj[key] = this.transformStateValue(prop.value as t.Expression);
            }
          }
        });
        this.componentState = stateObj;
      }
    }
  }

  // 处理 defaultProps 的代码
  private processDefaultPropsProperty(node: t.ClassProperty) {
    if (t.isIdentifier(node.key) && node.key.name === 'defaultProps' && node.value) {
      if (t.isObjectExpression(node.value)) {
        const defaultPropsObj: Record<string, any> = {};
        node.value.properties.forEach((prop) => {
          if (t.isObjectProperty(prop)) {
            const key = t.isIdentifier(prop.key)
              ? prop.key.name
              : t.isStringLiteral(prop.key)
              ? prop.key.value
              : '';

            if (key) {
              defaultPropsObj[key] = this.transformStateValue(prop.value as t.Expression);
            }
          }
        });
        this.componentDefaultProps = defaultPropsObj;
      }
    }
  }

  // 获取节点的下一个兄弟节点
  private getNextSibling(node: any): any {
    if (!node || !node.parentPath) return null;
    const siblings = node.parentPath.node.children;
    const currentIndex = siblings.indexOf(node);
    return currentIndex < siblings.length - 1 ? siblings[currentIndex + 1] : null;
  }

  // 标记节点为已处理
  private markNodeAsProcessed(node: any): void {
    if (!node) return;
    node._processed = true;
  }

  // 检查节点是否已被处理
  private isNodeProcessed(node: any): boolean {
    return node && node._processed === true;
  }

  // 新增：获取所有用到的组件名
  getUsedComponentNames(): string[] {
    return Array.from(this.usedComponentNames);
  }

  // 添加处理普通函数表达式的方法
  private transformFunctionExpressionToString(expr: t.FunctionExpression): string {
    logger('将普通函数表达式转换为字符串:', expr);

    const isAsync = expr.async ? 'async ' : '';
    try {
      // 处理函数参数
      const params = expr.params
        .map((param) => {
          try {
            return generate(param).code;
          } catch (e) {
            console.error('生成参数代码失败:', e);
            if (t.isIdentifier(param)) {
              return param.name;
            }
            return '...'; // 对于复杂参数模式，简化处理
          }
        })
        .join(', ');

      // 提取函数参数名列表，包括数组解构参数
      const paramNames: string[] = [];
      expr.params.forEach((param) => {
        if (t.isIdentifier(param)) {
          paramNames.push(param.name);
        } else if (t.isArrayPattern(param)) {
          // 处理数组解构参数，如 [key, type]
          param.elements.forEach((element) => {
            if (t.isIdentifier(element)) {
              paramNames.push(element.name);
            }
          });
        }
      });

      // 处理函数体
      let bodyCode = '';
      try {
        bodyCode = generate(expr.body).code;
        logger('生成的函数体代码块:', bodyCode);
      } catch (e) {
        console.error('生成函数体代码块失败:', e);
        // 失败时回退到原来的处理方式
        bodyCode = this.processBlockStatement(expr.body);
      }

      const validatedCode = this.transformJSFunctionAddThis(bodyCode, paramNames);

      // 组合成完整的函数
      return `${isAsync}function(${params}) ${validatedCode}`;
    } catch (error) {
      console.error('使用generate生成函数代码失败:', error);

      // 失败时回退到原来的处理方式
      const params = expr.params
        .map((param) => {
          if (t.isIdentifier(param)) {
            return param.name;
          }
          return '...'; // 对于复杂参数模式，简化处理
        })
        .join(', ');

      // 提取函数参数名列表，包括数组解构参数
      const paramNames: string[] = [];
      expr.params.forEach((param) => {
        if (t.isIdentifier(param)) {
          paramNames.push(param.name);
        } else if (t.isArrayPattern(param)) {
          // 处理数组解构参数，如 [key, type]
          param.elements.forEach((element) => {
            if (t.isIdentifier(element)) {
              paramNames.push(element.name);
            }
          });
        }
      });

      let bodyCode = this.processBlockStatement(expr.body);

      // 使用统一的 transformJSFunctionAddThis 方法处理 this 前缀
      bodyCode = this.transformJSFunctionAddThis(bodyCode, paramNames);

      return `${isAsync}function(${params}) ${bodyCode}`;
    }
  }
}

export const codeToSchema = new CodeToSchemaTransformer();
